@across-protocol/sdk 4.1.63-beta.0 → 4.1.63

package/src/arch/svm/utils.ts

@@ -1,222 +0,0 @@
-import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
-import {
-  address,
-  getProgramDerivedAddress,
-  getU64Encoder,
-  getAddressEncoder,
-  Address,
-  isAddress,
-  type TransactionSigner,
-} from "@solana/kit";
-import { BigNumber, getRelayDataHash, isUint8Array, SvmAddress } from "../../utils";
-import { SvmSpokeClient } from "@across-protocol/contracts";
-import { FillType, RelayData } from "../../interfaces";
-import { EventName, SVMEventNames, SVMProvider } from "./types";
-
-/**
- * Basic void TransactionSigner type
- */
-export const SolanaVoidSigner: (simulationAddress: string) => TransactionSigner<string> = (
-  simulationAddress: string
-) => {
-  return {
-    address: address(simulationAddress),
-    signAndSendTransactions: async () => {
-      return await Promise.resolve([]);
-    },
-  };
-};
-
-/**
- * Helper to determine if the current RPC network is devnet.
- */
-export async function isDevnet(rpc: SVMProvider): Promise<boolean> {
-  const genesisHash = await rpc.getGenesisHash().send();
-  return genesisHash === "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
-}
-
-/**
- * Parses event data from a transaction.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function parseEventData(eventData: any): any {
-  if (!eventData) return eventData;
-
-  if (Array.isArray(eventData)) {
-    return eventData.map(parseEventData);
-  }
-
-  if (typeof eventData === "object") {
-    if (eventData.constructor.name === "PublicKey") {
-      return address(eventData.toString());
-    }
-    if (BN.isBN(eventData)) {
-      return BigInt(eventData.toString());
-    }
-
-    // Convert each key from snake_case to camelCase and process the value recursively.
-    return Object.fromEntries(
-      Object.entries(eventData).map(([key, value]) => [snakeToCamel(key), parseEventData(value)])
-    );
-  }
-
-  return eventData;
-}
-
-/**
- * Decodes a raw event according to a supplied IDL.
- */
-export function decodeEvent(idl: Idl, rawEvent: string): { data: unknown; name: string } {
-  const event = new BorshEventCoder(idl).decode(rawEvent);
-  if (!event) throw new Error(`Malformed rawEvent for IDL ${idl.address}: ${rawEvent}`);
-  return {
-    name: event.name,
-    data: parseEventData(event.data),
-  };
-}
-
-/**
- * Converts a snake_case string to camelCase.
- */
-function snakeToCamel(s: string): string {
-  return s.replace(/(_\w)/g, (match) => match[1].toUpperCase());
-}
-
-/**
- * Gets the event name from a raw name.
- */
-export function getEventName(rawName: string): EventName {
-  if (Object.values(SVMEventNames).some((name) => rawName.includes(name))) return rawName as EventName;
-  throw new Error(`Unknown event name: ${rawName}`);
-}
-
-/**
- * Unwraps any data structure and converts Address types to strings and Uint8Array to hex or BigInt.
- * Recursively processes nested objects and arrays.
- */
-export function unwrapEventData(
-  data: unknown,
-  uint8ArrayKeysAsBigInt: string[] = ["depositId"],
-  currentKey?: string
-): unknown {
-  // Handle null/undefined
-  if (data == null) {
-    return data;
-  }
-  // Handle BigInt
-  if (typeof data === "bigint") {
-    return BigNumber.from(data);
-  }
-  // Handle Uint8Array and byte arrays
-  if (data instanceof Uint8Array || isUint8Array(data)) {
-    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data as number[]);
-    const hex = "0x" + Buffer.from(bytes).toString("hex");
-    if (currentKey && uint8ArrayKeysAsBigInt.includes(currentKey)) {
-      return BigNumber.from(hex);
-    }
-    return hex;
-  }
-  // Handle regular arrays (non-byte arrays)
-  if (Array.isArray(data)) {
-    return data.map((item) => unwrapEventData(item, uint8ArrayKeysAsBigInt));
-  }
-  // Handle strings (potential addresses)
-  if (typeof data === "string" && isAddress(data)) {
-    return SvmAddress.from(data).toBytes32();
-  }
-  // Handle objects
-  if (typeof data === "object") {
-    // Special case: if an object is in the context of the fillType key, then
-    // parse out the fillType from the object
-    if (currentKey === "fillType") {
-      const fillType = Object.keys(data)[0];
-      switch (fillType) {
-        case "FastFill":
-          return FillType.FastFill;
-        case "ReplacedSlowFill":
-          return FillType.ReplacedSlowFill;
-        case "SlowFill":
-          return FillType.SlowFill;
-        default:
-          throw new Error(`Unknown fill type: ${fillType}`);
-      }
-    }
-    // Special case: if an object is empty, return 0x
-    if (Object.keys(data).length === 0) {
-      return "0x";
-    }
-    return Object.fromEntries(
-      Object.entries(data as Record<string, unknown>).map(([key, value]) => [
-        key,
-        unwrapEventData(value, uint8ArrayKeysAsBigInt, key),
-      ])
-    );
-  }
-  // Return primitives as is
-  return data;
-}
-
-/**
- * Returns the PDA for the State account.
- * @param programId The SpokePool program ID.
- * @returns The PDA for the State account.
- */
-export async function getStatePda(programId: Address): Promise<Address> {
-  const intEncoder = getU64Encoder();
-  const seed = intEncoder.encode(0);
-  const [statePda] = await getProgramDerivedAddress({
-    programAddress: programId,
-    seeds: ["state", seed],
-  });
-  return statePda;
-}
-
-/**
- * Returns the fill status PDA for the given relay data.
- * @param programId The SpokePool program ID.
- * @param relayData The relay data to get the fill status PDA for.
- * @param destinationChainId The destination chain ID.
- * @returns The PDA for the fill status.
- */
-export async function getFillStatusPda(
-  programId: Address,
-  relayData: RelayData,
-  destinationChainId: number
-): Promise<Address> {
-  const relayDataHash = getRelayDataHash(relayData, destinationChainId);
-  const uint8RelayDataHash = new Uint8Array(Buffer.from(relayDataHash.slice(2), "hex"));
-  const [fillStatusPda] = await getProgramDerivedAddress({
-    programAddress: programId,
-    seeds: ["fills", uint8RelayDataHash],
-  });
-  return fillStatusPda;
-}
-
-/**
- * Returns the PDA for a route account on SVM Spoke.
- * @param originToken The origin token address.
- * @param seed The seed for the route account.
- * @param routeChainId The route chain ID.
- * @returns The PDA for the route account.
- */
-export async function getRoutePda(originToken: Address, seed: bigint, routeChainId: bigint): Promise<Address> {
-  const intEncoder = getU64Encoder();
-  const addressEncoder = getAddressEncoder();
-  const [pda] = await getProgramDerivedAddress({
-    programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
-    seeds: ["route", addressEncoder.encode(originToken), intEncoder.encode(seed), intEncoder.encode(routeChainId)],
-  });
-  return pda;
-}
-
-/**
- * Returns the PDA for the Event Authority.
- * @returns The PDA for the Event Authority.
- */
-export const getEventAuthority = async () => {
-  const [eventAuthority] = await getProgramDerivedAddress({
-    programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
-    seeds: ["__event_authority"],
-  });
-  return eventAuthority;
-};

package/src/clients/SpokePoolClient/SVMSpokePoolClient.ts

@@ -1,244 +0,0 @@
-import { Address, Rpc, RpcTransport, SolanaRpcApiFromTransport } from "@solana/kit";
-import winston from "winston";
-import {
-  SVMEventNames,
-  unwrapEventData,
-  getFillDeadline,
-  getTimestampForSlot,
-  getStatePda,
-  SvmCpiEventsClient,
-  relayFillStatus,
-  fillStatusArray,
-} from "../../arch/svm";
-import { FillStatus, RelayData, SortableEvent } from "../../interfaces";
-import {
-  BigNumber,
-  DepositSearchResult,
-  EventSearchConfig,
-  MakeOptional,
-  sortEventsAscendingInPlace,
-} from "../../utils";
-import { isUpdateFailureReason } from "../BaseAbstractClient";
-import { HubPoolClient } from "../HubPoolClient";
-import { knownEventNames, SpokePoolClient, SpokePoolUpdate } from "./SpokePoolClient";
-
-/**
- * SvmSpokePoolClient is a client for the SVM SpokePool program. It extends the base SpokePoolClient
- * and implements the abstract methods required for interacting with an SVM Spoke Pool.
- */
-export class SvmSpokePoolClient extends SpokePoolClient {
-  /**
-   * Protected constructor. Use the async create() method to instantiate.
-   */
-  protected constructor(
-    logger: winston.Logger,
-    hubPoolClient: HubPoolClient | null,
-    chainId: number,
-    deploymentSlot: bigint, // Using slot instead of block number for SVM
-    eventSearchConfig: MakeOptional<EventSearchConfig, "to">,
-    public svmEventsClient: SvmCpiEventsClient,
-    protected programId: Address,
-    protected statePda: Address
-  ) {
-    // Convert deploymentSlot to number for base class, might need refinement
-    super(logger, hubPoolClient, chainId, Number(deploymentSlot), eventSearchConfig);
-  }
-
-  /**
-   * Factory method to asynchronously create an instance of SvmSpokePoolClient.
-   */
-  public static async create(
-    logger: winston.Logger,
-    hubPoolClient: HubPoolClient | null,
-    chainId: number,
-    deploymentSlot: bigint,
-    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 }, // Provide default
-    rpc: Rpc<SolanaRpcApiFromTransport<RpcTransport>>
-  ): Promise<SvmSpokePoolClient> {
-    const svmEventsClient = await SvmCpiEventsClient.create(rpc);
-    const programId = svmEventsClient.getProgramAddress();
-    const statePda = await getStatePda(programId);
-    return new SvmSpokePoolClient(
-      logger,
-      hubPoolClient,
-      chainId,
-      deploymentSlot,
-      eventSearchConfig,
-      svmEventsClient,
-      programId,
-      statePda
-    );
-  }
-
-  /**
-   * Factory method to asynchronously create an instance of SvmSpokePoolClient with an existing event client.
-   */
-  public static async createWithExistingEventClient(
-    logger: winston.Logger,
-    hubPoolClient: HubPoolClient | null,
-    chainId: number,
-    deploymentSlot: bigint,
-    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 }, // Provide default
-    eventClient: SvmCpiEventsClient
-  ) {
-    const programId = eventClient.getProgramAddress();
-    const statePda = await getStatePda(programId);
-    return new SvmSpokePoolClient(
-      logger,
-      hubPoolClient,
-      chainId,
-      deploymentSlot,
-      eventSearchConfig,
-      eventClient,
-      programId,
-      statePda
-    );
-  }
-
-  public _queryableEventNames(): string[] {
-    // We want to take the internal event names relevant to
-    // the SVM SpokePoolClient and filter them against the
-    // knownEventNames list that we reference in practice
-    const internalEventNames = Object.values(SVMEventNames);
-    return internalEventNames.filter((e) => knownEventNames.includes(e));
-  }
-
-  /**
-   * Performs an update to refresh the state of this client by querying SVM events.
-   */
-  protected async _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
-    const searchConfig = await this.updateSearchConfig(this.svmEventsClient.getRpc());
-    if (isUpdateFailureReason(searchConfig)) {
-      const reason = searchConfig;
-      return { success: false, reason };
-    }
-
-    const deploymentSlot = BigInt(this.deploymentBlock);
-
-    const eventSearchConfigs = eventsToQuery.map((eventName) => {
-      if (!this._queryableEventNames().includes(eventName)) {
-        throw new Error(`SpokePoolClient: Cannot query unrecognised SpokePool event name: ${eventName}`);
-      }
-
-      const _searchConfig = { ...searchConfig }; // shallow copy
-
-      // By default, an event's query range is controlled by the `eventSearchConfig` passed in during instantiation.
-      // However, certain events have special overriding requirements to their search ranges:
-      // - EnabledDepositRoute: The full history is always required, so override the requested fromBlock.
-      if (eventName === "EnabledDepositRoute" && !this.isUpdated) {
-        _searchConfig.from = Number(deploymentSlot);
-      }
-
-      return _searchConfig as EventSearchConfig;
-    });
-
-    const spokePoolAddress = this.svmEventsClient.getProgramAddress();
-
-    this.log("debug", `Updating SpokePool client for chain ${this.chainId}`, {
-      eventsToQuery,
-      searchConfig,
-      spokePool: spokePoolAddress,
-    });
-
-    const timerStart = Date.now();
-
-    const [currentTime, ...eventsQueried] = await Promise.all([
-      this.svmEventsClient.getRpc().getBlockTime(BigInt(searchConfig.to)).send(),
-      ...eventsToQuery.map(async (eventName, idx) => {
-        const config = eventSearchConfigs[idx];
-        const events = await this.svmEventsClient.queryEvents(
-          eventName as SVMEventNames,
-          BigInt(config.from),
-          BigInt(config.to),
-          {
-            limit: config.maxLookBack,
-          }
-        );
-        return events.map(
-          (event): SortableEvent => ({
-            txnRef: event.signature,
-            blockNumber: Number(event.slot),
-            txnIndex: 0,
-            logIndex: 0,
-            ...(unwrapEventData(event.data) as Record<string, unknown>),
-          })
-        );
-      }),
-    ]);
-    this.log("debug", `Time to query new events from RPC for ${this.chainId}: ${Date.now() - timerStart} ms`);
-    if (currentTime < this.currentTime) {
-      const errMsg = `currentTime: ${currentTime} < ${this.currentTime}`;
-      throw new Error(`SvmSpokePoolClient::update: ${errMsg}`);
-    }
-
-    // Sort all events to ensure they are stored in a consistent order.
-    eventsQueried.forEach((events) => sortEventsAscendingInPlace(events));
-
-    return {
-      success: true,
-      currentTime: Number(currentTime), // uint32
-      searchEndBlock: searchConfig.to,
-      events: eventsQueried,
-    };
-  }
-
-  /**
-   * Retrieves the fill deadline buffer fetched from the State PDA.
-   * @note This function assumes that fill deadline buffer is a constant value in svm environments.
-   */
-  public override getMaxFillDeadlineInRange(_startSlot: number, _endSlot: number): Promise<number> {
-    return getFillDeadline(this.svmEventsClient.getRpc(), this.statePda);
-  }
-
-  /**
-   * Retrieves the timestamp for a given SVM slot number.
-   */
-  public override getTimestampForBlock(slot: number): Promise<number> {
-    return getTimestampForSlot(this.svmEventsClient.getRpc(), slot);
-  }
-
-  /**
-   * Retrieves the timestamp for a given SVM slot number.
-   * @note This function uses the same underlying function as getTimestampForBlock.
-   *       It is kept for consistency with the EVM SpokePoolClient.
-   */
-  public getTimeAt(slot: number): Promise<number> {
-    return getTimestampForSlot(this.svmEventsClient.getRpc(), slot);
-  }
-
-  /**
-   * Finds a deposit based on its deposit ID on the SVM chain.
-   * TODO: Implement SVM state query for deposit details.
-   */
-  public findDeposit(_depositId: BigNumber): Promise<DepositSearchResult> {
-    throw new Error("findDeposit not implemented for SVM");
-  }
-
-  /**
-   * 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);
-  }
-
-  /**
-   * Retrieves the fill status for an array of given relay data.
-   * @param relayData The array relay data to retrieve the fill status for.
-   * @param atHeight The slot at which to query the fill status.
-   * @returns The fill status for each of the given relay data.
-   */
-  public fillStatusArray(
-    relayData: RelayData[],
-    atHeight?: number,
-    destinationChainId?: number
-  ): Promise<(FillStatus | undefined)[]> {
-    // @note: deploymentBlock actually refers to the deployment slot. Also, blockTag should be a slot number.
-    destinationChainId ??= this.chainId;
-    return fillStatusArray(this.programId, relayData, destinationChainId, this.svmEventsClient, atHeight, this.logger);
-  }
-}

package/src/gasPriceOracle/adapters/solana.ts

@@ -1,45 +0,0 @@
-import { SVMProvider } from "../../arch/svm";
-import { toBN, dedupArray, parseUnits } from "../../utils";
-import { GasPriceEstimate } from "../types";
-import { GasPriceEstimateOptions } from "../oracle";
-import { CompilableTransactionMessage, TransactionMessageBytesBase64, compileTransaction } from "@solana/kit";
-
-/**
- * @notice Returns result of getFeeForMessage and getRecentPrioritizationFees RPC calls.
- * @returns GasPriceEstimate
- */
-export async function messageFee(provider: SVMProvider, opts: GasPriceEstimateOptions): Promise<GasPriceEstimate> {
-  const { unsignedTx: _unsignedTx } = opts;
-
-  // Cast the opaque unsignedTx type to a solana-kit CompilableTransactionMessage.
-  const unsignedTx = _unsignedTx as CompilableTransactionMessage;
-  const compiledTransaction = compileTransaction(unsignedTx);
-
-  // Get this base fee. This should result in LAMPORTS_PER_SIGNATURE * nSignatures.
-  const encodedTransactionMessage = Buffer.from(compiledTransaction.messageBytes).toString(
-    "base64"
-  ) as TransactionMessageBytesBase64;
-  const baseFeeResponse = await provider.getFeeForMessage(encodedTransactionMessage).send();
-
-  // Get the priority fee by calling `getRecentPrioritzationFees` on all the addresses in the transaction's instruction array.
-  const instructionAddresses = dedupArray(unsignedTx.instructions.map((instruction) => instruction.programAddress));
-  const recentPriorityFees = await provider.getRecentPrioritizationFees(instructionAddresses).send();
-
-  // Take the most recent 25 slots and find the average of the nonzero priority fees.
-  const nonzeroPrioritizationFees = recentPriorityFees
-    .slice(125)
-    .map((value) => value.prioritizationFee)
-    .filter((fee) => fee > 0);
-  const totalPrioritizationFees = nonzeroPrioritizationFees.reduce((acc, fee) => acc + fee, BigInt(0));
-
-  // Optionally impose a minimum priority fee, denoted in microLamports/computeUnit.
-  const flooredPriorityFeePerGas = parseUnits(process.env[`MIN_PRIORITY_FEE_PER_GAS_${opts.chainId}`] || "0", 6);
-  let microLamportsPerComputeUnit = toBN(totalPrioritizationFees / BigInt(nonzeroPrioritizationFees.length));
-  if (microLamportsPerComputeUnit.lt(flooredPriorityFeePerGas)) {
-    microLamportsPerComputeUnit = flooredPriorityFeePerGas;
-  }
-  return {
-    baseFee: toBN(baseFeeResponse!.value!),
-    microLamportsPerComputeUnit,
-  };
-}