@across-protocol/sdk 4.4.0-alpha.4 → 4.4.0-alpha.6

package/src/utils/AddressUtils.ts

@@ -1,7 +1,8 @@
 import { isAddress } from "viem";
 import { providers, utils } from "ethers";
 import bs58 from "bs58";
-import { BigNumber, chainIsEvm, chainIsSvm } from "./";
+import { TronWeb } from "tronweb";
+import { BigNumber, chainIsEvm, chainIsSvm, chainIsTvm } from "./";
 
 /**
  * Verify whether an address' bytecode resembles an EIP-7702 delegation.
@@ -90,7 +91,7 @@ export function isValidEvmAddress(address: string): boolean {
   try {
     const evmAddress = utils.hexZeroPad(utils.hexStripZeros(address), 20);
     return isAddress(utils.getAddress(evmAddress));
-  } catch (_e) {
+  } catch {
     return false;
   }
 }
@@ -105,7 +106,8 @@ export function isValidEvmAddress(address: string): boolean {
 export function toAddressType(address: string, chainId: number): Address {
   const rawAddress = address.startsWith("0x") ? utils.arrayify(address) : bs58.decode(address);
 
-  if (chainIsEvm(chainId) && EvmAddress.validate(rawAddress)) return new EvmAddress(rawAddress);
+  if (chainIsTvm(chainId)) return TvmAddress.from(address);
+  else if (chainIsEvm(chainId) && EvmAddress.validate(rawAddress)) return new EvmAddress(rawAddress);
   else if (chainIsSvm(chainId) && SvmAddress.validate(rawAddress)) return new SvmAddress(rawAddress);
 
   return new RawAddress(rawAddress);
@@ -185,6 +187,7 @@ export abstract class Address {
 
   // Checks if the address is valid on the given chain ID.
   isValidOn(chainId: number): boolean {
+    if (chainIsTvm(chainId)) return TvmAddress.validate(this.rawAddress);
     if (chainIsEvm(chainId)) return EvmAddress.validate(this.rawAddress);
     if (chainIsSvm(chainId)) return SvmAddress.validate(this.rawAddress);
     return false;
@@ -227,11 +230,15 @@ export abstract class Address {
   isSVM(): this is SvmAddress {
     return false;
   }
+
+  isTVM(): this is TvmAddress {
+    return false;
+  }
 }
 
 // Subclass of address which strictly deals with 20-byte addresses. These addresses are guaranteed to be valid EVM addresses, so `toAddress` will always succeed.
 export class EvmAddress extends Address {
-  private readonly _type = "evm";
+  private declare readonly _type: "evm";
 
   // On construction, validate that the address can indeed be coerced into an EVM address. Throw immediately if it cannot.
   constructor(rawAddress: Uint8Array) {
@@ -240,7 +247,6 @@ export class EvmAddress extends Address {
     }
 
     super(rawAddress);
-    this._type; // tsc noUnusedLocals appeasement.
   }
 
   static validate(rawAddress: Uint8Array): boolean {
@@ -266,7 +272,7 @@ export class EvmAddress extends Address {
 
 // Subclass of address which strictly deals SVM addresses. These addresses are guaranteed to be valid SVM addresses, so `toBase58` will always produce a valid Solana address.
 export class SvmAddress extends Address {
-  private readonly _type = "svm";
+  private declare readonly _type: "svm";
 
   // On construction, validate that the address is a point on Curve25519. Throw immediately if it is not.
   constructor(rawAddress: Uint8Array) {
@@ -275,7 +281,6 @@ export class SvmAddress extends Address {
     }
 
     super(rawAddress);
-    this._type; // tsc noUnusedLocals appeasement.
   }
 
   static validate(rawAddress: Uint8Array): boolean {
@@ -304,11 +309,58 @@ export class SvmAddress extends Address {
   }
 }
 
-export class RawAddress extends Address {
-  private readonly _type = "raw";
+// Subclass of address which handles TRON (TVM) addresses. Internally stores a 20-byte address (same as EVM),
+// but toNative() returns the TRON Base58Check-encoded address (T...).
+export class TvmAddress extends Address {
+  private declare readonly _type: "tvm";
+  private nativeAddress: string | undefined = undefined;
 
   constructor(rawAddress: Uint8Array) {
+    if (!TvmAddress.validate(rawAddress)) {
+      throw new Error(`${utils.hexlify(rawAddress)} is not a valid TVM address`);
+    }
+
     super(rawAddress);
-    this._type; // tsc noUnusedLocals appeasement.
   }
+
+  static validate(rawAddress: Uint8Array): boolean {
+    return (
+      rawAddress.length == 20 || (rawAddress.length === 32 && rawAddress.slice(0, 12).every((field) => field === 0))
+    );
+  }
+
+  override isTVM(): this is TvmAddress {
+    return true;
+  }
+
+  // Returns the TRON Base58Check-encoded address (T...).
+  override toNative(): string {
+    const computeNative = () => {
+      const hexString = utils.hexlify(this.rawAddress);
+      // Strip leading zeros to get the 20-byte portion, then convert to TRON format.
+      const evmHex = utils.hexZeroPad(utils.hexStripZeros(hexString), 20);
+      return TronWeb.address.fromHex(evmHex);
+    };
+    return (this.nativeAddress ??= computeNative());
+  }
+
+  override toHexString(): string {
+    return this.toEvmAddress();
+  }
+
+  // Constructs a new TvmAddress from a string. Accepts both 0x-prefixed hex and TRON Base58Check addresses.
+  static from(address: string): TvmAddress {
+    if (address.startsWith("0x")) {
+      return new this(utils.arrayify(address));
+    }
+    // For base58 Tron addresses, convert via TronWeb to get the hex representation.
+    const hex = TronWeb.address.toHex(address);
+    // TronWeb returns hex with a 0x41 prefix (TRON's address byte). Strip 0x41 to get 20 bytes.
+    const rawHex = "0x" + hex.slice(2);
+    return new this(utils.arrayify(rawHex));
+  }
+}
+
+export class RawAddress extends Address {
+  private declare readonly _type: "raw";
 }

package/src/utils/BlockExplorerUtils.ts

@@ -1,7 +1,7 @@
 import { ethers } from "ethers";
 import { PUBLIC_NETWORKS } from "../constants";
 import { createShortenedString } from "./FormattingUtils";
-import { chainIsEvm } from "./NetworkUtils";
+import { chainIsEvm, chainIsTvm } from "./NetworkUtils";
 import { isDefined } from "./TypeGuards";
 import bs58 from "bs58";
 
@@ -59,7 +59,7 @@ function _createBlockExplorerLinkMarkdown(addr: string, chainId = 1): string | n
     return `<unsupported chain/hash ${chainId}:${addr}>}`;
   }
   // Ensure that the first two characters are "0x". If they are not, append them.
-  if (addr.substring(0, 2) !== "0x" && chainIsEvm(chainId)) {
+  if (addr.substring(0, 2) !== "0x" && chainIsEvm(chainId) && !chainIsTvm(chainId)) {
     addr = `0x${addr}`;
     if (!ethers.utils.isHexString(addr)) {
       return null;
@@ -67,7 +67,18 @@ function _createBlockExplorerLinkMarkdown(addr: string, chainId = 1): string | n
   }
   // Resolve the short URL string.
   const shortURLString = createShortenedString(addr);
-  if (chainIsEvm(chainId)) {
+  if (chainIsTvm(chainId)) {
+    // TronScan-style URLs use `/#/transaction/...` and `/#/address/...`.
+    const txHexNoPrefix = addr.startsWith("0x") ? addr.slice(2) : addr;
+    if (txHexNoPrefix.length === 64 && ethers.utils.isHexString(`0x${txHexNoPrefix}`)) {
+      const txIdForUrl = txHexNoPrefix.toLowerCase();
+      return `<${constructURL(explorerDomain, ["#", "transaction", txIdForUrl])} | ${shortURLString}>`;
+    }
+    if (/^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(addr)) {
+      return `<${constructURL(explorerDomain, ["#", "address", addr])} | ${shortURLString}>`;
+    }
+    return null;
+  } else if (chainIsEvm(chainId)) {
     // Iterate over the two possible addr lengths.
     for (const [length, route] of [
       [66, "tx"],

package/src/utils/CCTPUtils.ts

@@ -1,9 +1,9 @@
 import { PUBLIC_NETWORKS, CCTP_NO_DOMAIN, PRODUCTION_NETWORKS, TEST_NETWORKS } from "@across-protocol/constants";
+import { fetchWithTimeout } from "./FetchUtils";
 import { BigNumber, ethers } from "ethers";
 
 import { Log } from "@ethersproject/abstract-provider";
 import { isDefined } from "./TypeGuards";
-import axios from "axios";
 import { chainIsProd } from "./NetworkUtils";
 import assert from "assert";
 import { bnZero } from "./BigNumberUtils";
@@ -236,10 +236,10 @@ export async function hasCCTPMessageBeenProcessedEvm(nonceHash: string, contract
  * @link https://developers.circle.com/api-reference/cctp/all/get-fast-burn-usdc-allowance
  */
 export async function getV2FastBurnAllowance(isMainnet: boolean): Promise<string> {
-  const httpResponse = await axios.get<CCTPV2APIGetFastBurnAllowanceResponse>(
+  const data = await fetchWithTimeout<CCTPV2APIGetFastBurnAllowanceResponse>(
     `https://iris-api${isMainnet ? "" : "-sandbox"}.circle.com/v2/fastBurn/USDC/allowance`
   );
-  return httpResponse.data.allowance.toString();
+  return data.allowance.toString();
 }
 
 /**
@@ -261,13 +261,13 @@ export async function getV2MinTransferFees(
   const endpoint = `https://iris-api${
     isMainnet ? "" : "-sandbox"
   }.circle.com/v2/burn/USDC/fees/${sourceDomain}/${destinationDomain}`;
-  const httpResponse = await axios.get<CCTPV2APIGetFeesResponse>(endpoint);
-  const standardFee = httpResponse.data.find((fee) => fee.finalityThreshold === CCTPV2_FINALITY_THRESHOLD_STANDARD);
+  const data = await fetchWithTimeout<CCTPV2APIGetFeesResponse>(endpoint);
+  const standardFee = data.find((fee) => fee.finalityThreshold === CCTPV2_FINALITY_THRESHOLD_STANDARD);
   assert(
     isDefined(standardFee?.minimumFee),
     `CCTPUtils#getTransferFees: Standard fee not found in API response: ${endpoint}`
   );
-  const fastFee = httpResponse.data.find((fee) => fee.finalityThreshold === CCTPV2_FINALITY_THRESHOLD_FAST);
+  const fastFee = data.find((fee) => fee.finalityThreshold === CCTPV2_FINALITY_THRESHOLD_FAST);
   assert(isDefined(fastFee?.minimumFee), `CCTPUtils#getTransferFees: Fast fee not found in API response: ${endpoint}`);
   return {
     standard: BigNumber.from(standardFee.minimumFee),
@@ -288,13 +288,11 @@ export async function fetchAttestationsForTxn(
   transactionHash: string,
   isMainnet: boolean
 ): Promise<CCTPV2APIGetAttestationResponse> {
-  const httpResponse = await axios.get<CCTPV2APIGetAttestationResponse>(
+  return await fetchWithTimeout<CCTPV2APIGetAttestationResponse>(
     `https://iris-api${
       isMainnet ? "" : "-sandbox"
     }.circle.com/v2/messages/${sourceDomainId}?transactionHash=${transactionHash}`
   );
-
-  return httpResponse.data;
 }
 
 /**

package/src/utils/EventUtils.ts

@@ -18,6 +18,7 @@ export function spreadEvent(args: Result | Record<string, unknown>): { [key: str
     switch (typeof args[key]) {
       case "boolean": // fallthrough
       case "number":
+      case "bigint":
       case "string":
         returnedObject[key] = args[key];
         break;

package/src/utils/FetchUtils.ts

@@ -0,0 +1,113 @@
+export type FetchHeaders = { [key: string]: unknown };
+export type FetchQueryParams = Record<string, unknown>;
+
+export class HttpError extends Error {
+  constructor(
+    public readonly status: number,
+    message: string
+  ) {
+    super(message);
+    this.name = "HttpError";
+  }
+}
+
+export function isHttpError(error: unknown): error is HttpError {
+  return error instanceof HttpError;
+}
+
+const toStringRecord = (headers: FetchHeaders): Record<string, string> => {
+  const normalizedHeaders: Record<string, string> = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value !== undefined && value !== null) {
+      normalizedHeaders[key.toLowerCase()] = String(value);
+    }
+  }
+  return normalizedHeaders;
+};
+
+const applyQueryParams = (url: string, params: FetchQueryParams): string => {
+  if (Object.keys(params).length === 0) return url;
+
+  const parsedUrl = new URL(url);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null) {
+      parsedUrl.searchParams.append(key, String(value));
+    }
+  }
+
+  return parsedUrl.toString();
+};
+
+async function baseFetch<T = unknown>(
+  url: string,
+  method: string,
+  body: string | undefined,
+  params: FetchQueryParams,
+  headers: FetchHeaders,
+  timeout?: number,
+  responseType: "json" | "text" = "json"
+): Promise<T> {
+  const fullUrl = applyQueryParams(url, params);
+  const response = await fetch(fullUrl, {
+    method,
+    body,
+    headers: toStringRecord(headers),
+    ...(timeout && timeout > 0 && { signal: AbortSignal.timeout(timeout) }),
+  });
+
+  // Read body as text first — body can only be consumed once, and we need
+  // the raw text for meaningful error messages if JSON parsing fails.
+  const text = await response.text();
+
+  if (!response.ok) {
+    let errorMessage: string | undefined;
+    try {
+      errorMessage = (JSON.parse(text) as { error?: string })?.error;
+    } catch {
+      // Response body wasn't JSON — fall through to default message.
+    }
+    throw new HttpError(response.status, errorMessage ?? `HTTP ${response.status}: ${response.statusText}`);
+  }
+
+  if (responseType === "text") {
+    return text as T;
+  }
+
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    const contentType = response.headers.get("content-type") ?? "unknown";
+    throw new Error(
+      `Expected JSON response from ${fullUrl} but received content-type: ${contentType} (body: ${text.slice(0, 256)})`
+    );
+  }
+}
+
+export function fetchWithTimeout<T = unknown>(
+  url: string,
+  params: FetchQueryParams = {},
+  headers: FetchHeaders = {},
+  timeout?: number,
+  responseType: "json" | "text" = "json"
+): Promise<T> {
+  return baseFetch<T>(url, "GET", undefined, params, headers, timeout, responseType);
+}
+
+export function postWithTimeout<T = unknown>(
+  url: string,
+  body: unknown,
+  params: FetchQueryParams = {},
+  headers: FetchHeaders = {},
+  timeout?: number,
+  responseType: "json" | "text" = "json"
+): Promise<T> {
+  return baseFetch<T>(
+    url,
+    "POST",
+    JSON.stringify(body),
+    params,
+    { "Content-Type": "application/json", ...headers },
+    timeout,
+    responseType
+  );
+}

package/src/utils/JSONUtils.ts

@@ -17,7 +17,7 @@ export function parseJSONWithNumericString(jsonString: string): unknown | undefi
       }
       return value;
     });
-  } catch (e) {
+  } catch {
     return undefined;
   }
 }

package/src/utils/Multicall.ts

@@ -21,6 +21,7 @@ const MULTICALL_DEPLOYER = "0x05f32B3cC3888453ff71B01135B34FF8e41263F2";
 
 const NON_DETERMINISTIC_MULTICALL_ADDRESSES = {
   [CHAIN_IDs.LENS]: "0x6b6dEa4D80e3077D076733A04c48F63c3BA49320",
+  [CHAIN_IDs.TRON]: "0x32a4f47a74a6810bd0bf861cabab99656a75de9e", // @todo: Base58?
   [CHAIN_IDs.ZK_SYNC]: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
   [CHAIN_IDs.LENS_SEPOLIA]: "0x8A44EDE8a6843a997bC0Cc4659e4dB1Da8f91116",
 };

package/src/utils/NetworkUtils.ts

@@ -134,6 +134,15 @@ export function chainIsSvm(chainId: number): boolean {
   return PUBLIC_NETWORKS[chainId]?.family === ChainFamily.SVM;
 }
 
+/**
+ * Determines whether a chain ID runs on a TVM-like execution layer (e.g. TRON).
+ * @param chainId Chain ID to evaluate.
+ * @returns True if chain corresponding to chainId has a TVM-like execution layer.
+ */
+export function chainIsTvm(chainId: number): boolean {
+  return PUBLIC_NETWORKS[chainId]?.family === ChainFamily.TVM;
+}
+
 /**
  * Determines whether a chain ID has a native gas token.
  * @param chainId Chain ID to evaluate.
@@ -166,13 +175,14 @@ export function chainIsOFTEnabled(chainId: number): boolean {
   // This is backwards vs. CCTP logic because Across support for OFTs is limited vs. OFT deployments.
   const oftEnabled = [
     CHAIN_IDs.ARBITRUM,
-    CHAIN_IDs.POLYGON,
     CHAIN_IDs.HYPEREVM,
+    CHAIN_IDs.INK,
+    CHAIN_IDs.MEGAETH,
     CHAIN_IDs.MONAD,
     CHAIN_IDs.PLASMA,
-    CHAIN_IDs.MEGAETH,
+    CHAIN_IDs.POLYGON,
+    CHAIN_IDs.TRON, // tbd!!!
     CHAIN_IDs.UNICHAIN,
-    CHAIN_IDs.INK,
   ];
   return oftEnabled.includes(chainId) && PRODUCTION_NETWORKS[chainId]?.oftEid !== OFT_NO_EID;
 }
@@ -194,7 +204,7 @@ export function chainRequiresL1ToL2Finalization(chainId: number): boolean {
 export function getOriginFromURL(url: string): string {
   try {
     return new URL(url).origin;
-  } catch (e) {
+  } catch {
     return "UNKNOWN";
   }
 }

package/src/utils/TypeGuards.ts

@@ -1,6 +1,7 @@
 import { SVMProvider } from "../arch/svm/types";
 import { EvmProvider } from "../arch/evm/types";
 import { providers } from "ethers";
+import { TronWeb } from "tronweb";
 
 export function isPromiseFulfilled<T>(
   promiseSettledResult: PromiseSettledResult<T>
@@ -18,6 +19,10 @@ export function isDefined<T>(input: T | null | undefined): input is T {
   return input !== null && input !== undefined;
 }
 
-export function isEvmProvider(provider: EvmProvider | SVMProvider): provider is EvmProvider {
+export function isTvmProvider(provider: EvmProvider | SVMProvider | TronWeb): provider is TronWeb {
+  return typeof (provider as TronWeb)?.trx?.getEnergyPrices === "function";
+}
+
+export function isEvmProvider(provider: EvmProvider | SVMProvider | TronWeb): provider is EvmProvider {
   return provider instanceof providers.Provider;
 }

package/src/utils/abi/contracts/SP1AutoVerifier.json

@@ -0,0 +1,25 @@
+[
+  {
+    "type": "function",
+    "name": "verifyProof",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "pure"
+  }
+]

package/src/utils/abi/typechain/SP1AutoVerifier.ts

@@ -0,0 +1,112 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface SP1AutoVerifierInterface extends utils.Interface {
+  functions: {
+    "verifyProof(bytes32,bytes,bytes)": FunctionFragment;
+  };
+
+  getFunction(nameOrSignatureOrTopic: "verifyProof"): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "verifyProof",
+    values: [BytesLike, BytesLike, BytesLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "verifyProof",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface SP1AutoVerifier extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: SP1AutoVerifierInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    verifyProof(
+      arg0: BytesLike,
+      arg1: BytesLike,
+      arg2: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<[void]>;
+  };
+
+  verifyProof(
+    arg0: BytesLike,
+    arg1: BytesLike,
+    arg2: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<void>;
+
+  callStatic: {
+    verifyProof(
+      arg0: BytesLike,
+      arg1: BytesLike,
+      arg2: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    verifyProof(
+      arg0: BytesLike,
+      arg1: BytesLike,
+      arg2: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    verifyProof(
+      arg0: BytesLike,
+      arg1: BytesLike,
+      arg2: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

package/src/utils/abi/typechain/factories/SP1AutoVerifier__factory.ts

@@ -0,0 +1,49 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  SP1AutoVerifier,
+  SP1AutoVerifierInterface,
+} from "../SP1AutoVerifier";
+
+const _abi = [
+  {
+    type: "function",
+    name: "verifyProof",
+    inputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32",
+      },
+      {
+        name: "",
+        type: "bytes",
+        internalType: "bytes",
+      },
+      {
+        name: "",
+        type: "bytes",
+        internalType: "bytes",
+      },
+    ],
+    outputs: [],
+    stateMutability: "pure",
+  },
+] as const;
+
+export class SP1AutoVerifier__factory {
+  static readonly abi = _abi;
+  static createInterface(): SP1AutoVerifierInterface {
+    return new utils.Interface(_abi) as SP1AutoVerifierInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): SP1AutoVerifier {
+    return new Contract(address, _abi, signerOrProvider) as SP1AutoVerifier;
+  }
+}

package/src/utils/abi/typechain/factories/index.ts

@@ -254,6 +254,7 @@ export { ProxyAdmin__factory } from "./ProxyAdmin__factory";
 export { ReentrancyGuard__factory } from "./ReentrancyGuard__factory";
 export { ReentrancyGuardUpgradeable__factory } from "./ReentrancyGuardUpgradeable__factory";
 export { Router_Adapter__factory } from "./Router_Adapter__factory";
+export { SP1AutoVerifier__factory } from "./SP1AutoVerifier__factory";
 export { SP1Helios__factory } from "./SP1Helios__factory";
 export { SafeCast__factory } from "./SafeCast__factory";
 export { SafeERC20__factory } from "./SafeERC20__factory";

package/src/utils/abi/typechain/index.ts

@@ -254,6 +254,7 @@ export type { ProxyAdmin } from "./ProxyAdmin";
 export type { ReentrancyGuard } from "./ReentrancyGuard";
 export type { ReentrancyGuardUpgradeable } from "./ReentrancyGuardUpgradeable";
 export type { Router_Adapter } from "./Router_Adapter";
+export type { SP1AutoVerifier } from "./SP1AutoVerifier";
 export type { SP1Helios } from "./SP1Helios";
 export type { SafeCast } from "./SafeCast";
 export type { SafeERC20 } from "./SafeERC20";
@@ -572,6 +573,7 @@ export { ShortStrings__factory } from "./factories/ShortStrings__factory";
 export { SimpleContract__factory } from "./factories/SimpleContract__factory";
 export { SkinnyOptimisticOracleInterface__factory } from "./factories/SkinnyOptimisticOracleInterface__factory";
 export { Solana_Adapter__factory } from "./factories/Solana_Adapter__factory";
+export { SP1AutoVerifier__factory } from "./factories/SP1AutoVerifier__factory";
 export { SP1Helios__factory } from "./factories/SP1Helios__factory";
 export { SpokePool__factory } from "./factories/SpokePool__factory";
 export { SpokePoolEIP7702Test__factory } from "./factories/SpokePoolEIP7702Test__factory";

package/src/utils/index.ts

@@ -1,5 +1,4 @@
 export * from "./common";
-export * from "./abi";
 export * from "./ArrayUtils";
 export * from "./BlockUtils";
 export * from "./BlockFinder";
@@ -12,7 +11,6 @@ export * from "./TokenUtils";
 export * from "./LogUtils";
 export * from "./BundleUtils";
 export * from "./JSONUtils";
-export * from "./IPFSUtils";
 export * from "./NumberUtils";
 export * from "./DeploymentUtils";
 export * from "./FormattingUtils";
@@ -29,3 +27,4 @@ export * from "./AddressUtils";
 export * from "./SpokeUtils";
 export * from "./CCTPUtils";
 export * from "./HyperLiquidUtils";
+export * from "./FetchUtils";

package/dist/cjs/src/caching/IPFS/PinataIPFSClient.d.ts

@@ -1,11 +0,0 @@
-import { CachingMechanismInterface } from "../../interfaces";
-import { Struct } from "superstruct";
-import winston from "winston";
-export declare class PinataIPFSClient implements CachingMechanismInterface {
-    private client;
-    private publicGatewayURL;
-    private logger?;
-    constructor(projectId: string, projectSecret: string, publicGatewayURL: string, logger?: winston.Logger);
-    get<ObjectType>(key?: string, _structValidator?: Struct<unknown, unknown>): Promise<ObjectType | null>;
-    set<T>(key: string, value: T): Promise<string | undefined>;
-}