@across-protocol/sdk 4.4.0-alpha.9 → 4.4.1

package/src/arch/evm/UpgradeUtils.ts

@@ -6,13 +6,19 @@ import { paginatedEventQuery } from "../../utils";
  * @param contract A contract instance (must be a UUPS or transparent proxy that emits the Upgraded event).
  * @param startBlock Optional start of the block range (inclusive). Defaults to 0.
  * @param endBlock Optional end of the block range (inclusive). Defaults to latest.
+ * @param maxLookBack Optional eth_getLogs chunk size. Required on RPCs that cap the range (e.g. Chainstack Tron).
  * @returns An array of block numbers at which upgrades occurred, sorted ascending.
  */
-export async function get1967Upgrades(contract: Contract, startBlock?: number, endBlock?: number): Promise<number[]> {
+export async function get1967Upgrades(
+  contract: Contract,
+  startBlock?: number,
+  endBlock?: number,
+  maxLookBack?: number
+): Promise<number[]> {
   const from = startBlock ?? 0;
   const to = endBlock ?? (await contract.provider.getBlockNumber());
 
-  const events = await paginatedEventQuery(contract, contract.filters.Upgraded(), { from, to });
+  const events = await paginatedEventQuery(contract, contract.filters.Upgraded(), { from, to, maxLookBack });
 
   return events.map(({ blockNumber }) => blockNumber);
 }

package/src/arch/svm/SpokeUtils.ts

@@ -1,5 +1,6 @@
-import { MessageTransmitterClient, SvmSpokeClient, TokenMessengerMinterClient } from "../../svm";
-import { decodeMessageHeader } from "../../svm/web3-v1/cctpHelpers";
+import { MessageTransmitterClient, SvmSpokeClient, TokenMessengerMinterClient } from "@across-protocol/contracts";
+import { decodeFillStatusAccount, fetchState } from "@across-protocol/contracts/dist/src/svm/clients/SvmSpoke";
+import { decodeMessageHeader } from "@across-protocol/contracts/dist/src/svm/web3-v1";
 import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
@@ -209,7 +210,7 @@ async function _callGetTimestampForSlotWithRetry(
  * @returns fill deadline buffer
  */
 export async function getFillDeadline(provider: SVMProvider, statePda: Address): Promise<number> {
-  const state = await SvmSpokeClient.fetchState(provider, statePda);
+  const state = await fetchState(provider, statePda);
   return state.data.fillDeadlineBuffer;
 }
 
@@ -291,7 +292,7 @@ export async function findDeposit(
   const blockNumber = Number(depositEvent.slot);
   const txnRef = depositEvent.signature.toString();
 
-  const rawData = unwrapEventData(depositEvent.data, ["depositId", "outputAmount"]) as Record<string, unknown>;
+  const rawData = unwrapEventData(depositEvent.data, ["depositId", "outputAmount"]);
   const { originChainId, ...deposit } = unpackDepositEvent(
     { ...rawData, blockNumber, txnRef, txnIndex, logIndex },
     CHAIN_IDs.SOLANA
@@ -340,7 +341,7 @@ export async function relayFillStatus(
 
     // If the PDA exists, return the stored fill status
     if (fillStatusAccount.exists) {
-      const decodedAccountData = SvmSpokeClient.decodeFillStatusAccount(fillStatusAccount);
+      const decodedAccountData = decodeFillStatusAccount(fillStatusAccount);
       return decodedAccountData.data.status;
     }
     // If the PDA doesn't exist and the deadline hasn't passed yet, the deposit must be unfilled,
@@ -482,7 +483,7 @@ export async function findFillEvent(
     return;
   }
 
-  const rawFill = unwrapEventData(rawEvent.data, ["depositId", "inputAmount"]) as SortableEvent;
+  const rawFill = unwrapEventData<SortableEvent>(rawEvent.data, ["depositId", "inputAmount"]);
   const fill = unpackFillEvent(rawFill, destinationChainId);
   return fill satisfies FillWithBlock;
 }
@@ -1067,7 +1068,7 @@ async function fetchBatchFillStatusFromPdaAccounts(
   const fillStatuses = pdaAccounts.flat().map((account, index) => {
     // If the PDA exists, we can fetch the status directly.
     if (account.exists) {
-      const decodedAccount = SvmSpokeClient.decodeFillStatusAccount(account);
+      const decodedAccount = decodeFillStatusAccount(account);
       return decodedAccount.data.status;
     }
 

package/src/arch/svm/eventsClient.ts

@@ -1,7 +1,6 @@
 import { Idl } from "@coral-xyz/anchor";
-import { getDeployedAddress } from "@across-protocol/contracts";
-import { SvmSpokeIdl } from "../../svm";
-import { getSolanaChainId } from "../../svm/web3-v1/helpers";
+import { getDeployedAddress, SvmSpokeIdl } from "@across-protocol/contracts";
+import { getSolanaChainId } from "@across-protocol/contracts/dist/src/svm/web3-v1";
 import {
   address,
   Address,
@@ -258,22 +257,15 @@ export class SvmCpiEventsClient {
     }
 
     return depositEvents.map((event) => {
-      const unwrappedEventArgs = unwrapEventData(event as Record<string, unknown>, [
-        "depositId",
-        "outputAmount",
-      ]) as Record<"data", Deposit> &
-        Record<
-          "data",
-          {
-            depositor: string;
-            recipient: string;
-            exclusiveRelayer: string;
-            inputToken: string;
-            outputToken: string;
-          }
-        >;
-
-      const { data } = unwrappedEventArgs;
+      const data = unwrapEventData<
+        Deposit & {
+          depositor: string;
+          recipient: string;
+          exclusiveRelayer: string;
+          inputToken: string;
+          outputToken: string;
+        }
+      >(event.data, ["depositId", "outputAmount"]);
       return {
         ...data,
         depositor: toAddressType(data.depositor, data.originChainId),
@@ -326,22 +318,15 @@ export class SvmCpiEventsClient {
     }
 
     return fillEvents.map((event) => {
-      const unwrappedEventData = unwrapEventData(event as Record<string, unknown>, [
-        "depositId",
-        "inputAmount",
-      ]) as Record<"data", Fill> &
-        Record<
-          "data",
-          {
-            depositor: string;
-            recipient: string;
-            exclusiveRelayer: string;
-            inputToken: string;
-            outputToken: string;
-          }
-        >;
-
-      const { data } = unwrappedEventData;
+      const data = unwrapEventData<
+        Fill & {
+          depositor: string;
+          recipient: string;
+          exclusiveRelayer: string;
+          inputToken: string;
+          outputToken: string;
+        }
+      >(event.data, ["depositId", "inputAmount"]);
       return {
         ...data,
         depositor: toAddressType(data.depositor, data.originChainId),

package/src/arch/svm/types.ts

@@ -1,4 +1,4 @@
-import { SvmSpokeClient } from "../../svm";
+import { SvmSpokeClient } from "@across-protocol/contracts";
 import {
   Address,
   Rpc,

package/src/arch/svm/utils.ts

@@ -1,4 +1,4 @@
-import { MessageTransmitterClient, SvmSpokeClient } from "../../svm";
+import { MessageTransmitterClient, SvmSpokeClient } from "@across-protocol/contracts";
 import { SpokePool__factory } from "../../typechain";
 import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
 import {
@@ -25,7 +25,7 @@ import assert from "assert";
 import bs58 from "bs58";
 import { ethers } from "ethers";
 import { FillType, RelayData, RelayDataWithMessageHash } from "../../interfaces";
-import { BigNumber, Address as SdkAddress, biMin, getMessageHash, isDefined, isUint8Array } from "../../utils";
+import { BigNumber, Address as SdkAddress, getMessageHash, isDefined, isUint8Array } from "../../utils";
 import { getTimestampForSlot, getSlot, getRelayDataHash } from "./SpokeUtils";
 import {
   AttestedCCTPMessage,
@@ -88,36 +88,6 @@ export async function getNearestSlotTime(
   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
- * how many slots to rotate through.
- */
-export async function getLatestFinalizedSlotWithBlock(
-  provider: SVMProvider,
-  logger: winston.Logger,
-  maxSlot: bigint,
-  maxLookback = 1000
-): Promise<number> {
-  const opts = { maxSupportedTransactionVersion: 0, transactionDetails: "none", rewards: false } as const;
-  const { slot: finalizedSlot } = await getNearestSlotTime(provider, { commitment: "finalized" }, logger);
-  const endSlot = biMin(maxSlot, finalizedSlot);
-
-  let slot = endSlot;
-  do {
-    const block = await provider.getBlock(slot, opts).send();
-    if (isDefined(block) && [block.blockHeight, block.blockTime].every(isDefined)) {
-      break;
-    }
-  } while (--maxLookback > 0 && --slot > 0);
-
-  if (maxLookback === 0) {
-    throw new Error(`Unable to find Solana block between slots [${slot}, ${endSlot}]`);
-  }
-
-  return Number(slot);
-}
-
 /**
  * Parses event data from a transaction.
  */
@@ -179,10 +149,32 @@ export function getEventName(rawName: string): EventName {
 }
 
 /**
- * Unwraps any data structure and converts Address types to strings and Uint8Array to hex or BigInt.
- * Recursively processes nested objects and arrays.
+ * Type guard for the shape returned at the top level by `unwrapEventDataInner` — a non-null,
+ * non-array object suitable for use as an event data record.
+ */
+function isUnwrappedRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * Top-level entry point for unwrapping SVM event data. Asserts at runtime that the unwrapped value
+ * is a record — the expected shape for an event data struct — and returns it as `T`. The runtime
+ * check proves record-shape; the caller's type argument names the specific shape (e.g. `Deposit`
+ * with stringified addresses). The cast is encapsulated here so call sites stay assertion-free.
+ */
+export function unwrapEventData<T = Record<string, unknown>>(data: unknown, uint8ArrayKeysAsBigInt?: string[]): T {
+  const result = unwrapEventDataInner(data, uint8ArrayKeysAsBigInt);
+  if (!isUnwrappedRecord(result)) {
+    throw new Error("unwrapEventData: top-level event data must unwrap to a non-null, non-array object");
+  }
+  return result as T;
+}
+
+/**
+ * Recursive helper. Unwraps any data structure, converting Address types to strings and Uint8Array
+ * to hex or BigInt. Returns `unknown` since intermediate values may be primitives, arrays, or scalars.
  */
-export function unwrapEventData(
+function unwrapEventDataInner(
   data: unknown,
   uint8ArrayKeysAsBigInt: string[] = ["depositId", "outputAmount", "inputAmount"],
   currentKey?: string
@@ -210,7 +202,7 @@ export function unwrapEventData(
   }
   // Handle regular arrays (non-byte arrays)
   if (Array.isArray(data)) {
-    return data.map((item) => unwrapEventData(item, uint8ArrayKeysAsBigInt));
+    return data.map((item) => unwrapEventDataInner(item, uint8ArrayKeysAsBigInt));
   }
   // Handle strings (potential addresses)
   if (typeof data === "string" && isAddress(data)) {
@@ -241,7 +233,7 @@ export function unwrapEventData(
     return Object.fromEntries(
       Object.entries(data as Record<string, unknown>).map(([key, value]) => [
         key,
-        unwrapEventData(value, uint8ArrayKeysAsBigInt, key),
+        unwrapEventDataInner(value, uint8ArrayKeysAsBigInt, key),
       ])
     );
   }

package/src/arch/tvm/MessageUtils.ts

@@ -0,0 +1,72 @@
+import { RelayData, SpeedUpCommon } from "../../interfaces";
+import { BigNumber, bnZero, isDefined, isMessageEmpty, toBN } from "../../utils";
+
+// Tron prices each byte of a transaction's serialized raw_data + signature at this many
+// SUN of bandwidth when the relayer's free bandwidth allowance has been exhausted. The
+// rate is set by Tron governance; refresh from `wallet/getchainparameters` if it drifts.
+const TVM_BANDWIDTH_SUN_PER_BYTE = 1000;
+
+// Tron raw_data envelope (contract type, ref_block, timestamp, expiration, fee_limit)
+// plus a single ECDSA signature. Measured empirically against `fillRelay` transactions
+// emitted by the production relayer; varies by ~10 bytes between calls.
+const TVM_RAW_DATA_OVERHEAD_BYTES = 290;
+
+// `fillRelay(V3RelayData, uint256 repaymentChainId, bytes32 repaymentAddress)` ABI
+// encoding, excluding the `message` payload (which is dynamic).
+//   4   selector
+//  96   top-level head: offset(V3RelayData) + repaymentChainId + repaymentAddress
+// 384   V3RelayData struct head: 11 static fields inline + 1 offset(message)
+//  32   message length header
+const TVM_FILL_RELAY_FIXED_CALLDATA_BYTES = 4 + 96 + 384 + 32;
+
+// Extra ABI footprint when a speed-up signature is present and the relayer must call
+// `fillRelayWithUpdatedDeposit(V3RelayData, ..., uint256 updatedOutputAmount, bytes32
+// updatedRecipient, bytes updatedMessage, bytes speedUpSignature)`. The original
+// `message` still lives inside V3RelayData and is already counted above; this constant
+// captures only what's *additional* to the plain `fillRelay` encoding.
+//  128   4 extra head slots: updatedOutputAmount + updatedRecipient + offset(updatedMessage) + offset(speedUpSignature)
+//   32   updatedMessage length header (the padded body is added per-call below)
+//   32   speedUpSignature length header
+//   96   65-byte ECDSA signature padded to 3 EVM words
+const TVM_SPEED_UP_FIXED_CALLDATA_EXTRA_BYTES = 128 + 32 + 32 + 96;
+
+function paddedMessageByteLength(message: string | undefined): number {
+  if (!isDefined(message) || isMessageEmpty(message)) return 0;
+  const bytes = Math.max(0, Math.floor((message.length - 2) / 2));
+  return Math.ceil(bytes / 32) * 32;
+}
+
+/**
+ * Estimate the bandwidth cost (in SUN) of a Tron fill for `deposit`.
+ *
+ * On Tron, transaction bytes consume bandwidth — distinct from energy (paid via the tx
+ * fee limit and modeled in `nativeGasCost`). When the relayer has no free bandwidth
+ * staked, every byte burns 1,000 SUN. For message-bearing fills this is non-trivial:
+ * the message dominates calldata size, so the cost scales linearly with message length.
+ *
+ * Sped-up deposits (those carrying a `speedUpSignature`) are filled via
+ * `fillRelayWithUpdatedDeposit`, which carries the original `V3RelayData` *and*
+ * `updatedMessage`/`speedUpSignature` as additional ABI args. Both messages are charged.
+ *
+ * The estimate is conservative — it assumes zero free bandwidth (worst case). Relayers
+ * that stake TRX for bandwidth pay 0 onchain; this still represents the true marginal
+ * cost of consuming that staked allowance.
+ */
+export function getAuxiliaryNativeTokenCost(
+  deposit: RelayData & Partial<SpeedUpCommon> & { speedUpSignature?: string }
+): BigNumber {
+  const paddedMessageBytes = paddedMessageByteLength(deposit.message);
+
+  let speedUpExtraBytes = 0;
+  if (isDefined(deposit.speedUpSignature) && deposit.speedUpSignature !== "0x") {
+    speedUpExtraBytes = TVM_SPEED_UP_FIXED_CALLDATA_EXTRA_BYTES + paddedMessageByteLength(deposit.updatedMessage);
+  }
+
+  const calldataBytes = TVM_FILL_RELAY_FIXED_CALLDATA_BYTES + paddedMessageBytes + speedUpExtraBytes;
+  const txBytes = TVM_RAW_DATA_OVERHEAD_BYTES + calldataBytes;
+
+  return toBN(txBytes).mul(TVM_BANDWIDTH_SUN_PER_BYTE);
+}
+
+// Re-export so other arches can reference the zero default if needed.
+export const tvmBandwidthCostZero = bnZero;

package/src/arch/tvm/SpokeUtils.ts

@@ -16,6 +16,8 @@ import {
 
 type BlockTag = providers.BlockTag;
 
+type SearchConfig = { from?: number; maxLookBack?: number };
+
 // Re-export functions that work unchanged on TRON's JSON-RPC.
 export { populateV3Relay, getTimestampForBlock, fillStatusArray } from "../evm/SpokeUtils";
 
@@ -48,11 +50,12 @@ const FALLBACK_FILL_DEADLINE_BUFFER = 21600; // 6 hours in seconds
 export async function getMaxFillDeadlineInRange(
   spokePool: Contract,
   startBlock: number,
-  endBlock: number
+  endBlock: number,
+  eventSearchConfig?: SearchConfig
 ): Promise<number> {
   const [fillDeadlineBuffer, upgrades] = await Promise.all([
     spokePool.fillDeadlineBuffer(),
-    get1967Upgrades(spokePool, startBlock, endBlock),
+    get1967Upgrades(spokePool, startBlock, endBlock, eventSearchConfig?.maxLookBack),
   ]);
 
   const currentBuffer = Number(fillDeadlineBuffer);
@@ -80,7 +83,8 @@ export async function findDepositBlock(
   spokePool: Contract,
   depositId: BigNumber,
   lowBlock: number,
-  highBlock?: number
+  highBlock?: number,
+  eventSearchConfig?: SearchConfig
 ): Promise<number | undefined> {
   if (isUnsafeDepositId(depositId)) {
     throw new Error(`Cannot search for depositId ${depositId}`);
@@ -92,7 +96,7 @@ export async function findDepositBlock(
   const events = await paginatedEventQuery(
     spokePool,
     spokePool.filters.FundsDeposited(null, null, null, null, null, depositId),
-    { from: lowBlock, to: highBlock }
+    { from: lowBlock, to: highBlock, maxLookBack: eventSearchConfig?.maxLookBack }
   );
 
   if (events.length === 0) {
@@ -113,7 +117,8 @@ export async function relayFillStatus(
   spokePool: Contract,
   relayData: RelayData,
   blockTag: BlockTag = "latest",
-  destinationChainId?: number
+  destinationChainId?: number,
+  eventSearchConfig?: SearchConfig
 ): Promise<FillStatus> {
   if (blockTag === "latest") {
     return evmRelayFillStatus(spokePool, relayData, blockTag, destinationChainId);
@@ -132,14 +137,14 @@ export async function relayFillStatus(
     return FillStatus.Unfilled;
   }
 
-  // Reconstruct from events up to the requested block.
-  const fromBlock = 0;
+  const fromBlock = eventSearchConfig?.from ?? 0;
   const toBlock = Number(blockTag);
+  const { maxLookBack } = eventSearchConfig ?? {};
 
   const fillEvents = await paginatedEventQuery(
     spokePool,
     spokePool.filters.FilledRelay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
-    { from: fromBlock, to: toBlock }
+    { from: fromBlock, to: toBlock, maxLookBack }
   );
 
   if (fillEvents.length > 0) {
@@ -151,7 +156,7 @@ export async function relayFillStatus(
     const slowFillEvents = await paginatedEventQuery(
       spokePool,
       spokePool.filters.RequestedSlowFill(null, null, null, null, relayData.originChainId, relayData.depositId),
-      { from: fromBlock, to: toBlock }
+      { from: fromBlock, to: toBlock, maxLookBack }
     );
 
     if (slowFillEvents.length > 0) {
@@ -171,7 +176,8 @@ export async function findFillBlock(
   spokePool: Contract,
   relayData: RelayData,
   lowBlockNumber: number,
-  highBlockNumber?: number
+  highBlockNumber?: number,
+  eventSearchConfig?: SearchConfig
 ): Promise<number | undefined> {
   const { provider } = spokePool;
   highBlockNumber ??= await provider.getBlockNumber();
@@ -180,7 +186,7 @@ export async function findFillBlock(
   const events = await paginatedEventQuery(
     spokePool,
     spokePool.filters.FilledRelay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
-    { from: lowBlockNumber, to: highBlockNumber }
+    { from: lowBlockNumber, to: highBlockNumber, maxLookBack: eventSearchConfig?.maxLookBack }
   );
 
   if (events.length === 0) {
@@ -198,7 +204,8 @@ export async function findFillEvent(
   spokePool: Contract,
   relayData: RelayData,
   lowBlockNumber: number,
-  highBlockNumber?: number
+  highBlockNumber?: number,
+  eventSearchConfig?: SearchConfig
 ): Promise<FillWithBlock | undefined> {
   const { provider } = spokePool;
   highBlockNumber ??= await provider.getBlockNumber();
@@ -206,7 +213,7 @@ export async function findFillEvent(
   const events = await paginatedEventQuery(
     spokePool,
     spokePool.filters.FilledRelay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
-    { from: lowBlockNumber, to: highBlockNumber }
+    { from: lowBlockNumber, to: highBlockNumber, maxLookBack: eventSearchConfig?.maxLookBack }
   );
 
   if (events.length === 0) {

package/src/arch/tvm/index.ts

@@ -1,2 +1,3 @@
 export * from "./SpokeUtils";
 export * from "./TransactionUtils";
+export * from "./MessageUtils";