@across-protocol/sdk 4.3.139 → 4.3.140-alpha.0

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -7,6 +7,12 @@ import {
   relayFillStatus,
   getTimestampForBlock as _getTimestampForBlock,
 } from "../../arch/evm";
+import {
+  relayFillStatus as relayFillStatusTvm,
+  getMaxFillDeadlineInRange as getMaxFillDeadlineTvm,
+  getTimeAt as _getTimeAtTvm,
+  findDepositBlock as findDepositBlockTvm,
+} from "../../arch/tvm";
 import { DepositWithBlock, FillStatus, Log, RelayData } from "../../interfaces";
 import {
   BigNumber,
@@ -17,6 +23,7 @@ import {
   toBN,
   EvmAddress,
   unpackDepositEvent,
+  chainIsTvm,
 } from "../../utils";
 import {
   EventSearchConfig,
@@ -36,6 +43,8 @@ import { EVM_SPOKE_POOL_CLIENT_TYPE } from "./types";
  */
 export class EVMSpokePoolClient extends SpokePoolClient {
   readonly type = EVM_SPOKE_POOL_CLIENT_TYPE;
+  readonly tvm: boolean;
+
   constructor(
     logger: winston.Logger,
     public readonly spokePool: Contract,
@@ -46,10 +55,12 @@ export class EVMSpokePoolClient extends SpokePoolClient {
   ) {
     super(logger, hubPoolClient, chainId, deploymentBlock, eventSearchConfig);
     this.spokePoolAddress = EvmAddress.from(spokePool.address);
+    this.tvm = chainIsTvm(this.chainId);
   }
 
   public override relayFillStatus(relayData: RelayData, atHeight?: number): Promise<FillStatus> {
-    return relayFillStatus(this.spokePool, relayData, atHeight, this.chainId);
+    const fillStatusHandler = this.tvm ? relayFillStatusTvm : relayFillStatus;
+    return fillStatusHandler(this.spokePool, relayData, atHeight, this.chainId);
   }
 
   public override fillStatusArray(relayData: RelayData[], atHeight?: number): Promise<(FillStatus | undefined)[]> {
@@ -57,7 +68,8 @@ export class EVMSpokePoolClient extends SpokePoolClient {
   }
 
   public override getMaxFillDeadlineInRange(startBlock: number, endBlock: number): Promise<number> {
-    return getMaxFillDeadline(this.spokePool, startBlock, endBlock);
+    const maxFillDeadlineInRangeHandler = this.tvm ? getMaxFillDeadlineTvm : getMaxFillDeadline;
+    return maxFillDeadlineInRangeHandler(this.spokePool, startBlock, endBlock);
   }
 
   private _availableEventsOnSpoke(eventNames: string[] = knownEventNames): { [eventName: string]: EventFilter } {
@@ -72,6 +84,42 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     return Object.keys(this._availableEventsOnSpoke(knownEventNames));
   }
 
+  /**
+   * Retrieve the on-chain time at a specific block.
+   * EVM reads SpokePool.getCurrentTime() via multicall with a historical blockTag.
+   * @param blockNumber The block number to query.
+   * @returns The on-chain time as a number.
+   */
+  protected async _getCurrentTime(blockNumber: number): Promise<number> {
+    if (this.tvm) {
+      const block = await this.spokePool.provider.getBlock(blockNumber);
+      const currentTime = block.timestamp;
+      if (currentTime < this.currentTime) {
+        throw new Error(`EVMSpokePoolClient::_getCurrentTimeTvm: currentTime: ${currentTime} < ${this.currentTime}`);
+      }
+      return currentTime;
+    }
+    const { spokePool } = this;
+    const multicallFunctions = ["getCurrentTime"];
+    const multicallOutput = await spokePool.callStatic.multicall(
+      multicallFunctions.map((f) => spokePool.interface.encodeFunctionData(f)),
+      { blockTag: blockNumber }
+    );
+
+    const [currentTime] = multicallFunctions.map(
+      (fn, idx) => spokePool.interface.decodeFunctionResult(fn, multicallOutput[idx])[0]
+    );
+
+    if (!BigNumber.isBigNumber(currentTime) || currentTime.lt(this.currentTime)) {
+      const errMsg = BigNumber.isBigNumber(currentTime)
+        ? `currentTime: ${currentTime} < ${toBN(this.currentTime)}`
+        : `currentTime is not a BigNumber: ${JSON.stringify(currentTime)}`;
+      throw new Error(`EVMSpokePoolClient::update: ${errMsg}`);
+    }
+
+    return currentTime.toNumber();
+  }
+
   protected override async _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
     const searchConfig = await this.updateSearchConfig(this.spokePool.provider);
     if (isUpdateFailureReason(searchConfig)) {
@@ -107,25 +155,14 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     });
 
     const timerStart = Date.now();
-    const multicallFunctions = ["getCurrentTime"];
-    const [multicallOutput, ...events] = await Promise.all([
-      spokePool.callStatic.multicall(
-        multicallFunctions.map((f) => spokePool.interface.encodeFunctionData(f)),
-        { blockTag: searchConfig.to }
-      ),
+    const [currentTime, ...events] = await Promise.all([
+      this._getCurrentTime(searchConfig.to),
       ...eventSearchConfigs.map((config) => paginatedEventQuery(this.spokePool, config.filter, config.searchConfig)),
     ]);
     this.log("debug", `Time to query new events from RPC for ${this.chainId}: ${Date.now() - timerStart} ms`);
 
-    const [currentTime] = multicallFunctions.map(
-      (fn, idx) => spokePool.interface.decodeFunctionResult(fn, multicallOutput[idx])[0]
-    );
-
-    if (!BigNumber.isBigNumber(currentTime) || currentTime.lt(this.currentTime)) {
-      const errMsg = BigNumber.isBigNumber(currentTime)
-        ? `currentTime: ${currentTime} < ${toBN(this.currentTime)}`
-        : `currentTime is not a BigNumber: ${JSON.stringify(currentTime)}`;
-      throw new Error(`EVMSpokePoolClient::update: ${errMsg}`);
+    if (currentTime < this.currentTime) {
+      throw new Error(`EVMSpokePoolClient::update: currentTime: ${currentTime} < ${this.currentTime}`);
     }
 
     // Sort all events to ensure they are stored in a consistent order.
@@ -138,14 +175,15 @@ export class EVMSpokePoolClient extends SpokePoolClient {
 
     return {
       success: true,
-      currentTime: currentTime.toNumber(), // uint32
+      currentTime,
       searchEndBlock: searchConfig.to,
       events: eventsWithBlockNumber,
     };
   }
 
   public override getTimeAt(blockNumber: number): Promise<number> {
-    return _getTimeAt(this.spokePool, blockNumber);
+    const getTimeAtHandler = this.tvm ? _getTimeAtTvm : _getTimeAt;
+    return getTimeAtHandler(this.spokePool, blockNumber);
   }
 
   public override async findDeposit(depositId: BigNumber): Promise<DepositSearchResult> {
@@ -190,12 +228,22 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     return _getTimestampForBlock(this.spokePool.provider, blockNumber);
   }
 
-  private async queryDepositEvents(
+  /**
+   * Find the block at which a deposit was created.
+   * EVM uses a binary-search over historical numberOfDeposits().
+   * TVM overrides this with an event-based lookup.
+   */
+  protected _findDepositBlock(depositId: BigNumber, lowBlock: number, highBlock?: number): Promise<number | undefined> {
+    const findDepositBlockHandler = this.tvm ? findDepositBlockTvm : findDepositBlock;
+    return findDepositBlockHandler(this.spokePool, depositId, lowBlock, highBlock);
+  }
+
+  protected async queryDepositEvents(
     depositId: BigNumber
   ): Promise<{ event: Log; elapsedMs: number } | { reason: string }> {
     const tStart = Date.now();
     const upperBound = this.latestHeightSearched || undefined;
-    const from = await findDepositBlock(this.spokePool, depositId, this.deploymentBlock, upperBound);
+    const from = await this._findDepositBlock(depositId, this.deploymentBlock, upperBound);
     const chain = getNetworkName(this.chainId);
 
     if (!from) {

package/src/gasPriceOracle/oracle.ts

@@ -113,6 +113,7 @@ function getGasPriceEthers(provider: providers.Provider, opts: GasPriceEstimateO
     [CHAIN_IDs.POLYGON]: polygon.gasStation,
     [CHAIN_IDs.SCROLL]: ethereum.legacy,
     [CHAIN_IDs.TEMPO]: ethereum.eip1559,
+    [CHAIN_IDs.TRON]: ethereum.legacy,
     [CHAIN_IDs.ZK_SYNC]: ethereum.legacy,
     // Testnet
     [CHAIN_IDs.POLYGON_AMOY]: polygon.gasStation,

package/src/relayFeeCalculator/chain-queries/baseQuery.ts

@@ -9,6 +9,7 @@ import { populateV3Relay } from "../../arch/evm";
 import {
   BigNumberish,
   EvmAddress,
+  TvmAddress,
   TransactionCostEstimate,
   BigNumber,
   toBNWei,
@@ -85,9 +86,15 @@ export class QueryBase implements QueryInterface {
     const { gasPrice = this.fixedGasPrice, gasUnits, opStackL1GasCostMultiplier } = options;
 
     const { recipient, outputToken, exclusiveRelayer } = relayData;
-    assert(recipient.isEVM(), `getGasCosts: recipient not an EVM address (${recipient})`);
-    assert(outputToken.isEVM(), `getGasCosts: outputToken not an EVM address (${outputToken})`);
-    assert(exclusiveRelayer.isEVM(), `getGasCosts: exclusiveRelayer not an EVM address (${exclusiveRelayer})`);
+    assert(recipient.isEVM() || recipient.isTVM(), `getGasCosts: recipient not an EVM-like address (${recipient})`);
+    assert(
+      outputToken.isEVM() || outputToken.isTVM(),
+      `getGasCosts: outputToken not an EVM-like address (${outputToken})`
+    );
+    assert(
+      exclusiveRelayer.isEVM() || exclusiveRelayer.isTVM(),
+      `getGasCosts: exclusiveRelayer not an EVM-like address (${exclusiveRelayer})`
+    );
 
     const tx = await this.getUnsignedTxFromDeposit({ ...relayData, recipient, outputToken, exclusiveRelayer }, relayer);
     const {
@@ -119,8 +126,8 @@ export class QueryBase implements QueryInterface {
   getUnsignedTxFromDeposit(
     relayData: Omit<RelayData, "recipient" | "outputToken"> & {
       destinationChainId: number;
-      recipient: EvmAddress;
-      outputToken: EvmAddress;
+      recipient: EvmAddress | TvmAddress;
+      outputToken: EvmAddress | TvmAddress;
     },
     relayer = getDefaultRelayer(relayData.destinationChainId)
   ): Promise<PopulatedTransaction> {
@@ -138,9 +145,18 @@ export class QueryBase implements QueryInterface {
     relayer = getDefaultRelayer(relayData.destinationChainId)
   ): Promise<BigNumber> {
     const { recipient, outputToken, exclusiveRelayer } = relayData;
-    assert(recipient.isEVM(), `getNativeGasCost: recipient not an EVM address (${recipient})`);
-    assert(outputToken.isEVM(), `getNativeGasCost: outputToken not an EVM address (${outputToken})`);
-    assert(exclusiveRelayer.isEVM(), `getNativeGasCost: exclusiveRelayer not an EVM address (${exclusiveRelayer})`);
+    assert(
+      recipient.isEVM() || recipient.isTVM(),
+      `getNativeGasCost: recipient not an EVM-like address (${recipient})`
+    );
+    assert(
+      outputToken.isEVM() || outputToken.isTVM(),
+      `getNativeGasCost: outputToken not an EVM-like address (${outputToken})`
+    );
+    assert(
+      exclusiveRelayer.isEVM() || exclusiveRelayer.isTVM(),
+      `getNativeGasCost: exclusiveRelayer not an EVM-like address (${exclusiveRelayer})`
+    );
 
     const unsignedTx = await this.getUnsignedTxFromDeposit(
       { ...relayData, recipient, outputToken, exclusiveRelayer },

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.
@@ -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);
@@ -187,6 +189,7 @@ export abstract class Address {
   isValidOn(chainId: number): boolean {
     if (chainIsEvm(chainId)) return EvmAddress.validate(this.rawAddress);
     if (chainIsSvm(chainId)) return SvmAddress.validate(this.rawAddress);
+    if (chainIsTvm(chainId)) return TvmAddress.validate(this.rawAddress);
     return false;
   }
 
@@ -227,6 +230,10 @@ 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.
@@ -304,6 +311,59 @@ export class SvmAddress extends Address {
   }
 }
 
+// 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 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 readonly _type = "raw";
 

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;
 }

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";