@across-protocol/sdk 4.3.18-alpha.1 → 4.3.19-alpha.1

package/src/arch/svm/SpokeUtils.ts

@@ -65,6 +65,7 @@ import {
 import { SvmCpiEventsClient } from "./eventsClient";
 import { SVM_NO_BLOCK_AT_SLOT, isSolanaError } from "./provider";
 import { AttestedCCTPMessage, SVMEventNames, SVMProvider } from "./types";
+import { getNearestSlotTime } from "./utils";
 
 /**
  * @note: Average Solana slot duration is about 400-500ms. We can be conservative
@@ -83,9 +84,10 @@ type ProtoFill = Omit<RelayData, "recipient" | "outputToken"> & {
  */
 export async function getTimestampForSlot(provider: SVMProvider, slotNumber: bigint): Promise<number | undefined> {
   // @note: getBlockTime receives a slot number, not a block number.
+  let _timestamp: bigint;
+
   try {
-    const blockTime = await provider.getBlockTime(slotNumber).send();
-    return Number(blockTime);
+    _timestamp = await provider.getBlockTime(slotNumber).send();
   } catch (err) {
     if (!isSolanaError(err)) {
       throw err;
@@ -98,6 +100,11 @@ export async function getTimestampForSlot(provider: SVMProvider, slotNumber: big
 
     throw err; // Unhandled Solana error.
   }
+
+  const timestamp = Number(_timestamp);
+  assert(BigInt(timestamp) === _timestamp, `Unexpected SVM block timestamp: ${_timestamp}`); // No truncation.
+
+  return timestamp;
 }
 
 /**
@@ -226,14 +233,17 @@ export async function relayFillStatus(
   const provider = svmEventsClient.getRpc();
   // Get fill status PDA using relayData
   const fillStatusPda = await getFillStatusPda(programId, relayData, destinationChainId);
-  const currentSlot = await provider.getSlot({ commitment: "confirmed" }).send();
+  let toSlot = BigInt(atHeight ?? 0);
 
   // If no specific slot is requested, try fetching the current status from the PDA
   if (atHeight === undefined) {
-    const [fillStatusAccount, currentSlotTimestamp] = await Promise.all([
-      fetchEncodedAccount(provider, fillStatusPda, { commitment: "confirmed" }),
-      getTimestampForSlot(provider, currentSlot),
+    const commitment = "confirmed";
+    const [fillStatusAccount, { slot: currentSlot, timestamp }] = await Promise.all([
+      fetchEncodedAccount(provider, fillStatusPda, { commitment }),
+      getNearestSlotTime(provider, { commitment }),
     ]);
+    toSlot = currentSlot;
+
     // If the PDA exists, return the stored fill status
     if (fillStatusAccount.exists) {
       const decodedAccountData = decodeFillStatusAccount(fillStatusAccount);
@@ -241,14 +251,12 @@ export async function relayFillStatus(
     }
     // If the PDA doesn't exist and the deadline hasn't passed yet, the deposit must be unfilled,
     // since PDAs can't be closed before the fill deadline.
-    else if (Number(currentSlotTimestamp) < relayData.fillDeadline) {
+    else if (timestamp < relayData.fillDeadline) {
       return FillStatus.Unfilled;
     }
   }
 
-  // If status couldn't be determined from the PDA, or if a specific slot was requested, reconstruct the status from events
-  const toSlot = atHeight ? BigInt(atHeight) : currentSlot;
-
+  // If status couldn't be determined from the PDA, or if a specific slot was requested, reconstruct from events.
   return resolveFillStatusFromPdaEvents(fillStatusPda, toSlot, svmEventsClient);
 }
 
@@ -816,7 +824,7 @@ export const createReceiveMessageInstruction = async (
   input: MessageTransmitterClient.ReceiveMessageInput,
   remainingAccounts: IAccountMeta<string>[]
 ) => {
-  const receiveMessageIx = await MessageTransmitterClient.getReceiveMessageInstruction(input);
+  const receiveMessageIx = MessageTransmitterClient.getReceiveMessageInstruction(input);
   (receiveMessageIx.accounts as IAccountMeta<string>[]).push(...remainingAccounts);
   return pipe(await createDefaultTransaction(solanaClient, signer), (tx) =>
     appendTransactionMessageInstruction(receiveMessageIx, tx)
@@ -919,15 +927,11 @@ async function fetchBatchFillStatusFromPdaAccounts(
   relayDataArray: RelayData[]
 ): Promise<(FillStatus | undefined)[]> {
   const chunkSize = 100; // SVM method getMultipleAccounts allows a max of 100 addresses per request
-  const currentSlot = await provider.getSlot({ commitment: "confirmed" }).send();
+  const commitment = "confirmed";
 
-  const [pdaAccounts, currentSlotTimestamp] = await Promise.all([
-    Promise.all(
-      chunk(fillStatusPdas, chunkSize).map((chunk) =>
-        fetchEncodedAccounts(provider, chunk, { commitment: "confirmed" })
-      )
-    ),
-    getTimestampForSlot(provider, currentSlot),
+  const [pdaAccounts, { timestamp }] = await Promise.all([
+    Promise.all(chunk(fillStatusPdas, chunkSize).map((chunk) => fetchEncodedAccounts(provider, chunk, { commitment }))),
+    getNearestSlotTime(provider, { commitment }),
   ]);
 
   const fillStatuses = pdaAccounts.flat().map((account, index) => {
@@ -939,7 +943,7 @@ async function fetchBatchFillStatusFromPdaAccounts(
 
     // If the PDA doesn't exist and the deadline hasn't passed yet, the deposit must be unfilled,
     // since PDAs can't be closed before the fill deadline.
-    if (Number(currentSlotTimestamp) < relayDataArray[index].fillDeadline) {
+    if (timestamp < relayDataArray[index].fillDeadline) {
       return FillStatus.Unfilled;
     }
 

package/src/arch/svm/utils.ts

@@ -1,7 +1,9 @@
+import assert from "assert";
 import { MessageTransmitterClient, SvmSpokeClient } from "@across-protocol/contracts";
 import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
 import {
   Address,
+  type Commitment,
   IInstruction,
   KeyPairSigner,
   address,
@@ -24,6 +26,7 @@ import { ethers } from "ethers";
 import { FillType, RelayData } from "../../interfaces";
 import { BigNumber, Address as SdkAddress, getRelayDataHash, isDefined, isUint8Array } from "../../utils";
 import { AttestedCCTPMessage, EventName, SVMEventNames, SVMProvider } from "./types";
+import { getTimestampForSlot } from "./SpokeUtils";
 
 export { isSolanaError } from "@solana/kit";
 
@@ -56,6 +59,27 @@ export function toAddress(address: SdkAddress): Address<string> {
   return address.toBase58() as Address<string>;
 }
 
+/**
+ * For a given slot (or implicit head of chain), find the immediate preceding slot that contained a block.
+ * @param provider SVM Provider instance.
+ * @param opts An object containing a specific slot number, or a Solana commitment, defaulting to "confirmed".
+ * @returns An object containing the slot number and the relevant timestamp for the block.
+ */
+export async function getNearestSlotTime(
+  provider: SVMProvider,
+  opts: { slot: bigint } | { commitment: Commitment } = { commitment: "confirmed" }
+): Promise<{ slot: bigint; timestamp: number }> {
+  let timestamp: number | undefined;
+  let slot = "slot" in opts ? opts.slot : await provider.getSlot(opts).send();
+
+  do {
+    timestamp = await getTimestampForSlot(provider, slot);
+  } while (!isDefined(timestamp) && --slot);
+  assert(isDefined(timestamp), `Unable to resolve block time for SVM slot ${slot}`);
+
+  return { slot, timestamp };
+}
+
 /**
  * Resolve the latest finalized slot, and then work backwards to find the nearest slot containing a block.
  * In most cases the first-resolved slot should also have a block. Avoid making arbitrary decisions about
@@ -285,15 +309,16 @@ export async function getTransferLiabilityPda(programId: Address, originToken: A
 /**
  * Returns the PDA for the SVM Spoke's root bundle account.
  * @param programId the address of the spoke pool.
- * @param statePda the spoke pool's state pda.
  * @param rootBundleId the associated root bundle ID.
  */
-export async function getRootBundlePda(programId: Address, state: Address, rootBundleId: number): Promise<Address> {
+export async function getRootBundlePda(programId: Address, rootBundleId: number): Promise<Address> {
+  const seedEncoder = getU64Encoder();
+  const seed = seedEncoder.encode(0); // Default seed.
+
   const intEncoder = getU32Encoder();
-  const addressEncoder = getAddressEncoder();
   const [pda] = await getProgramDerivedAddress({
     programAddress: programId,
-    seeds: ["root_bundle", addressEncoder.encode(state), intEncoder.encode(rootBundleId)],
+    seeds: ["root_bundle", seed, intEncoder.encode(rootBundleId)],
   });
   return pda;
 }

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

@@ -10,7 +10,6 @@ import {
   PoolRebalanceLeaf,
   Refund,
   RunningBalances,
-  SpokePoolClientsByChain,
 } from "../../../interfaces";
 import {
   bnZero,
@@ -19,8 +18,6 @@ import {
   count2DDictionaryValues,
   count3DDictionaryValues,
   toAddressType,
-  getImpliedBundleBlockRanges,
-  EvmAddress,
 } from "../../../utils";
 import {
   addLastRunningBalance,
@@ -31,7 +28,6 @@ import {
 } from "./PoolRebalanceUtils";
 import { AcrossConfigStoreClient } from "../../AcrossConfigStoreClient";
 import { HubPoolClient } from "../../HubPoolClient";
-import { BundleDataClient } from "../../BundleDataClient";
 import { buildPoolRebalanceLeafTree } from "./MerkleTreeUtils";
 
 // and expired deposits.
@@ -118,7 +114,7 @@ export function getEndBlockBuffers(
   return chainIdListForBundleEvaluationBlockNumbers.map((chainId: number) => blockRangeEndBlockBuffer[chainId] ?? 0);
 }
 
-export async function _buildPoolRebalanceRoot(
+export function _buildPoolRebalanceRoot(
   latestMainnetBlock: number,
   mainnetBundleEndBlock: number,
   bundleV3Deposits: BundleDepositsV3,
@@ -126,14 +122,9 @@ export async function _buildPoolRebalanceRoot(
   bundleSlowFillsV3: BundleSlowFills,
   unexecutableSlowFills: BundleExcessSlowFills,
   expiredDepositsToRefundV3: ExpiredDepositsToRefundV3,
-  clients: {
-    hubPoolClient: HubPoolClient;
-    configStoreClient: AcrossConfigStoreClient;
-    bundleDataClient: BundleDataClient;
-    spokePoolClients: SpokePoolClientsByChain;
-  },
+  clients: { hubPoolClient: HubPoolClient; configStoreClient: AcrossConfigStoreClient },
   maxL1TokenCountOverride?: number
-): Promise<PoolRebalanceRoot> {
+): PoolRebalanceRoot {
   // Running balances are the amount of tokens that we need to send to each SpokePool to pay for all instant and
   // slow relay refunds. They are decreased by the amount of funds already held by the SpokePool. Balances are keyed
   // by the SpokePool's network and L1 token equivalent of the L2 token to refund.
@@ -306,62 +297,9 @@ export async function _buildPoolRebalanceRoot(
     });
   });
 
-  // Add to the running balance value from the last valid root bundle proposal. A root bundle proposal which is still in liveness and has not yet been executed counts as a valid proposal.
-  // If the mainnetBundleEndBlock for this pool rebalance root corresponds to the pending root bundle or some root bundle before the pending root bundle, then we can fetch running balances directly from `ExecutedRootBundle` events.
-  if (
-    clients.hubPoolClient.getPendingRootBundle()?.bundleEvaluationBlockNumbers[0] === mainnetBundleEndBlock ||
-    !clients.hubPoolClient.hasPendingProposal() ||
-    clients.hubPoolClient
-      .getValidatedRootBundles()
-      .some((bundle) => bundle.bundleEvaluationBlockNumbers[0].toNumber() === mainnetBundleEndBlock)
-  ) {
-    addLastRunningBalance(latestMainnetBlock, runningBalances, clients.hubPoolClient);
-  } else {
-    // Otherwise, the pool rebalance root for this root bundle must be for an optimistic proposal, so we need to reconstruct the pool rebalance root for the pending root bundle to obtain the running balances.
-    // @dev It is safe to index the hub pool client's proposed root bundles here since there is guaranteed to be a pending proposal in this code block.
-    const mostRecentProposedRootBundle = clients.hubPoolClient.getLatestProposedRootBundle();
-    const blockRangesForChains = getImpliedBundleBlockRanges(
-      clients.hubPoolClient,
-      clients.configStoreClient,
-      mostRecentProposedRootBundle
-    );
-    // We are loading data from a pending root bundle, so we want to use arweave if possible.
-    const prevRootBundleData = await clients.bundleDataClient.loadData(
-      blockRangesForChains,
-      clients.spokePoolClients,
-      true
-    );
-    const prevPoolRebalanceRoot = await _buildPoolRebalanceRoot(
-      latestMainnetBlock,
-      blockRangesForChains[0][1],
-      prevRootBundleData.bundleDepositsV3,
-      prevRootBundleData.bundleFillsV3,
-      prevRootBundleData.bundleSlowFillsV3,
-      prevRootBundleData.unexecutableSlowFills,
-      prevRootBundleData.expiredDepositsToRefundV3,
-      clients,
-      maxL1TokenCountOverride
-    );
-    // Update the running balances by adding the pending root bundle's running balance amounts to this bundle's running balances.
-    const { runningBalances: prevRunningBalances } = prevPoolRebalanceRoot;
-    Object.keys(runningBalances).forEach((repaymentChainId) => {
-      Object.keys(runningBalances[Number(repaymentChainId)]).forEach((l1TokenAddress) => {
-        const updateRunningBalanceAmount = prevRunningBalances[Number(repaymentChainId)]?.[l1TokenAddress];
-        // If the pending root bundle didn't have a running balance, fall back to the last running balance for that token and chain pair.
-        const { runningBalance: fallbackRunningBalance } = clients.hubPoolClient.getRunningBalanceBeforeBlockForChain(
-          latestMainnetBlock,
-          Number(repaymentChainId),
-          EvmAddress.from(l1TokenAddress)
-        );
-        updateRunningBalance(
-          runningBalances,
-          Number(repaymentChainId),
-          l1TokenAddress,
-          updateRunningBalanceAmount ?? fallbackRunningBalance
-        );
-      });
-    });
-  }
+  // Add to the running balance value from the last valid root bundle proposal for {chainId, l1Token}
+  // combination if found.
+  addLastRunningBalance(latestMainnetBlock, runningBalances, clients.hubPoolClient);
 
   const leaves: PoolRebalanceLeaf[] = constructPoolRebalanceLeaves(
     mainnetBundleEndBlock,

package/src/clients/SpokePoolClient/SVMSpokePoolClient.ts

@@ -243,13 +243,8 @@ export class SVMSpokePoolClient extends SpokePoolClient {
   /**
    * Retrieves the fill status for a given relay data from the SVM chain.
    */
-  public override relayFillStatus(
-    relayData: RelayData,
-    atHeight?: number,
-    destinationChainId?: number
-  ): Promise<FillStatus> {
-    destinationChainId ??= this.chainId;
-    return relayFillStatus(this.programId, relayData, destinationChainId, this.svmEventsClient, atHeight);
+  public override relayFillStatus(relayData: RelayData, atHeight?: number): Promise<FillStatus> {
+    return relayFillStatus(this.programId, relayData, this.chainId, this.svmEventsClient, atHeight);
   }
 
   /**

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -150,10 +150,10 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
    */
   public getDepositsForDestinationChainWithDuplicates(destinationChainId: number): DepositWithBlock[] {
     const deposits = this.getDepositsForDestinationChain(destinationChainId);
-    const duplicateDeposits = deposits.reduce((acc, deposit) => {
+    const duplicateDeposits = deposits.reduce<DepositWithBlock[]>((acc, deposit) => {
       const duplicates = this._getDuplicateDeposits(deposit);
       return acc.concat(duplicates);
-    }, [] as DepositWithBlock[]);
+    }, []);
     return sortEventsAscendingInPlace(deposits.concat(duplicateDeposits.flat()));
   }
 
@@ -508,7 +508,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     if (eventsToQuery.includes("TokensBridged")) {
       for (const _event of queryResults[eventsToQuery.indexOf("TokensBridged")]) {
-        const event = _event as TokensBridged & {
+        const event = _event as Omit<TokensBridged, "l2TokenAddress"> & {
           l2TokenAddress: string;
         };
         this.tokensBridged.push({
@@ -521,7 +521,10 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     // Performs the indexing of a deposit-like spoke pool event.
     const queryDepositEvents = async (eventName: string) => {
       const depositEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((_event) => {
-        const event = _event as DepositWithBlock & {
+        const event = _event as Omit<
+          DepositWithBlock,
+          "depositor" | "recipient" | "inputToken" | "outputToken" | "exclusiveRelayer"
+        > & {
           depositor: string;
           recipient: string;
           inputToken: string;
@@ -595,7 +598,10 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     const querySpeedUpDepositEvents = (eventName: string) => {
       const speedUpEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? [])
         .map((_event) => {
-          const event = _event as SpeedUpWithBlock & { depositor: string; updatedRecipient: string };
+          const event = _event as Omit<SpeedUpWithBlock, "depositor" | "updatedRecipient"> & {
+            depositor: string;
+            updatedRecipient: string;
+          };
 
           const invalid = [event.depositor, event.updatedRecipient].some(
             (addr) => !EvmAddress.validate(ethersUtils.arrayify(addr))
@@ -643,7 +649,10 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     // Performs indexing of "requested slow fill"-like events.
     const queryRequestedSlowFillEvents = (eventName: string) => {
       const slowFillRequests = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((_event) => {
-        const event = _event as SlowFillRequestWithBlock & {
+        const event = _event as Omit<
+          SlowFillRequestWithBlock,
+          "depositor" | "recipient" | "inputToken" | "outputToken" | "exclusiveRelayer"
+        > & {
           depositor: string;
           recipient: string;
           inputToken: string;
@@ -686,14 +695,23 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     // Performs indexing of filled relay-like events.
     const queryFilledRelayEvents = (eventName: string) => {
       const fillEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((_event) => {
-        const event = _event as FillWithBlock & {
+        const event = _event as Omit<
+          FillWithBlock,
+          | "depositor"
+          | "recipient"
+          | "inputToken"
+          | "outputToken"
+          | "exclusiveRelayer"
+          | "relayer"
+          | "relayExecutionInfo"
+        > & {
           depositor: string;
           recipient: string;
           inputToken: string;
           outputToken: string;
           exclusiveRelayer: string;
           relayer: string;
-          relayExecutionInfo: RelayExecutionEventInfo & { updatedRecipient: string };
+          relayExecutionInfo: Omit<RelayExecutionEventInfo, "updatedRecipient"> & { updatedRecipient: string };
         };
         return {
           ...event,
@@ -744,11 +762,13 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     });
 
     if (eventsToQuery.includes("EnabledDepositRoute")) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const enableDepositsEvents = queryResults[eventsToQuery.indexOf("EnabledDepositRoute")].map((event: any) => ({
-        ...event,
-        originToken: toAddressType(event.originToken, CHAIN_IDs.MAINNET),
-      })) as EnabledDepositRouteWithBlock[];
+      const enableDepositsEvents = queryResults[eventsToQuery.indexOf("EnabledDepositRoute")].map((_event) => {
+        const event = _event as Omit<EnabledDepositRouteWithBlock, "originToken"> & { originToken: string };
+        return {
+          ...event,
+          originToken: toAddressType(event.originToken, CHAIN_IDs.MAINNET),
+        } as EnabledDepositRouteWithBlock;
+      });
 
       for (const event of enableDepositsEvents) {
         assign(this.depositRoutes, [event.originToken.toBytes32(), event.destinationChainId], event.enabled);
@@ -767,7 +787,10 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     if (eventsToQuery.includes("ExecutedRelayerRefundRoot")) {
       const refundEvents = queryResults[eventsToQuery.indexOf("ExecutedRelayerRefundRoot")];
       for (const _event of refundEvents) {
-        const event = _event as { l2TokenAddress: string; refundAddresses: string[] } & RelayerRefundExecutionWithBlock;
+        const event = _event as Omit<RelayerRefundExecutionWithBlock, "l2TokenAddress" | "refundAddresses"> & {
+          l2TokenAddress: string;
+          refundAddresses: string[];
+        };
         this.relayerRefundExecutions.push({
           ...event,
           l2TokenAddress: toAddressType(event.l2TokenAddress, this.chainId),

package/src/clients/mocks/MockSpokePoolClient.ts

@@ -279,7 +279,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     });
   }
 
-  setTokensBridged(tokensBridged: TokensBridged): Log {
+  setTokensBridged(tokensBridged: Omit<TokensBridged, "l2TokenAddress"> & { l2TokenAddress: string }): Log {
     const event = "TokensBridged";
     const topics = [tokensBridged.chainId, tokensBridged.leafId, tokensBridged.l2TokenAddress];
     const args = { ...tokensBridged };

package/src/utils/EventUtils.ts

@@ -3,27 +3,11 @@ import { Result } from "@ethersproject/abi";
 import { Contract, Event, EventFilter } from "ethers";
 import { Log, SortableEvent } from "../interfaces";
 import { delay } from "./common";
-import { isDefined, toBN, BigNumberish, toEvmAddress } from "./";
+import { isDefined, toBN, BigNumberish } from "./";
 
 const maxRetries = 3;
 const retrySleepTime = 10;
 
-// Event fields which changed from an `address` to `bytes32` after the SVM contract upgrade.
-const knownExtendedAddressFields = [
-  // TokensBridged
-  "l2TokenAddress",
-  // FundsDeposited/FilledRelay/RequestedSlowFill
-  "inputToken",
-  "outputToken",
-  "depositor",
-  "recipient",
-  "exclusiveRelayer",
-  // FilledRelay
-  "relayer",
-  // RequestedSpeedUpDeposit
-  "updatedRecipient",
-];
-
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function spreadEvent(args: Result | Record<string, unknown>): { [key: string]: any } {
   const keys = Object.keys(args).filter((key: string) => isNaN(+key)); // Extract non-numeric keys.
@@ -83,18 +67,6 @@ export function spreadEvent(args: Result | Record<string, unknown>): { [key: str
     returnedObject.depositId = toBN(returnedObject.depositId as BigNumberish);
   }
 
-  // Truncate all fields which may be bytes32 into a bytes20 string.
-  for (const field of knownExtendedAddressFields) {
-    if (isDefined(returnedObject[field])) {
-      let address = String(returnedObject[field]);
-      try {
-        address = toEvmAddress(address);
-        // eslint-disable-next-line no-empty
-      } catch (_) {}
-      returnedObject[field] = address;
-    }
-  }
-
   return returnedObject;
 }