@raac/rpc 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/types/contracts/psm/previewRedeem.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Previews redeeming `shares` (share base units) from a PSM vault.
+ * @returns The assets out after fee, in base asset base units.
+ */
+export declare function previewRedeem(chainId: ChainId, vaultKeyOrAddress: string, shares: bigint, provider?: Provider): Promise<bigint>;

package/dist/types/contracts/psm/previewSwap.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Previews swapping `amountIn` of `tokenIn` for `tokenOut` through a PSM vault.
+ * @returns The amount out, in tokenOut base units.
+ */
+export declare function previewSwap(chainId: ChainId, vaultKeyOrAddress: string, tokenIn: string, tokenOut: string, amountIn: bigint, provider?: Provider): Promise<bigint>;

package/dist/types/contracts/psm/redeem.d.ts

@@ -0,0 +1,9 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Redeems `shares` (share base units) from a PSM vault, after a ready exit request.
+ * Use `previewProportionalSplit` beforehand to preview the 3-way split.
+ * @param minAssetsOut The minimum total assets to accept, in base asset base units.
+ * @param receiver The address to receive the assets.
+ */
+export declare function redeem(chainId: ChainId, vaultKeyOrAddress: string, shares: bigint, receiver: string, minAssetsOut: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/psm/requestExit.d.ts

@@ -0,0 +1,4 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/** Requests an exit from a PSM vault for `shares` (share base units), starting the withdraw timelock. */
+export declare function requestExit(chainId: ChainId, vaultKeyOrAddress: string, shares: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/psm/swap.d.ts

@@ -0,0 +1,8 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Swaps `amountIn` of `tokenIn` for `tokenOut` through a PSM vault.
+ * @param minAmountOut The minimum output to accept, in tokenOut base units.
+ * @param receiver The address to receive the output.
+ */
+export declare function swap(chainId: ChainId, vaultKeyOrAddress: string, tokenIn: string, tokenOut: string, amountIn: bigint, minAmountOut: bigint, receiver: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/tokens/veRAAC/getRewardTokens.d.ts

@@ -0,0 +1,10 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Gets the reward token addresses configured on the veRAAC contract.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The reward token addresses.
+ */
+export declare const getRewardTokens: (chainId: ChainId, provider?: Provider) => Promise<string[]>;

package/dist/types/contracts/zeno/createAuction.d.ts

@@ -1,17 +1,27 @@
 import { Signer } from "ethers";
 import { ChainId } from "../../configs/chains/index";
+/** How an auction's ZENO is backed by the underlying asset. Mirrors `IAuction.FundingMode`. */
+export declare enum FundingMode {
+    /** The ZENO must already hold underlying for the full allocation. */
+    Prefilled = 0,
+    /** The issuer tops up the underlying before maturity. */
+    Float = 1
+}
 /**
- * Creates a ZENO auction through the AuctionFactory.
+ * Creates a ZENO auction through the AuctionFactory. Only the factory owner can call this.
  * @param chainId The chain id.
  * @param zenoAddress The ZENO bond token sold.
- * @param usdcAddress The payment token bidders pay with.
- * @param businessAddress The issuer receiving the proceeds.
+ * @param tokenAddress The payment token bidders pay with.
+ * @param issuer The issuer receiving the proceeds.
  * @param auctionStartTime UNIX timestamp (seconds) the auction starts.
  * @param auctionEndTime UNIX timestamp (seconds) the auction ends.
  * @param startingPrice The Dutch auction starting price, in payment token base units per whole ZENO.
  * @param reservePrice The Dutch auction reserve price, in payment token base units per whole ZENO.
  * @param totalZenoAllocated The ZENO offered, in ZENO base units.
- * @param signer The signer sending the transaction.
+ * @param fundingMode How the ZENO is backed; `Prefilled` requires the ZENO to hold underlying for the full allocation.
+ * @param initialOwner The owner of the new auction.
+ * @param signer The factory owner.
+ * @returns The address of the new auction.
  */
-declare function createAuction(chainId: ChainId, zenoAddress: string, usdcAddress: string, businessAddress: string, auctionStartTime: bigint, auctionEndTime: bigint, startingPrice: bigint, reservePrice: bigint, totalZenoAllocated: bigint, signer: Signer): Promise<void>;
+declare function createAuction(chainId: ChainId, zenoAddress: string, tokenAddress: string, issuer: string, auctionStartTime: bigint, auctionEndTime: bigint, startingPrice: bigint, reservePrice: bigint, totalZenoAllocated: bigint, fundingMode: FundingMode, initialOwner: string, signer: Signer): Promise<string>;
 export default createAuction;

package/dist/types/contracts/zeno/createZeno.d.ts

@@ -1,4 +1,13 @@
 import { Signer } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function createZeno(chainId: ChainId, usdcAddress: string, maturityDate: string, signer: Signer): Promise<string>;
+/**
+ * Creates a ZENO bond through the ZENOFactory. Only the factory owner can call this.
+ * @param chainId The chain id.
+ * @param tokenAddress The underlying asset the bond redeems for.
+ * @param maturityDate UNIX timestamp (seconds) the bond matures. Must be in the future.
+ * @param initialOwner The owner of the new bond, typically the auction or a multisig.
+ * @param signer The factory owner.
+ * @returns The address of the new ZENO bond.
+ */
+declare function createZeno(chainId: ChainId, tokenAddress: string, maturityDate: bigint, initialOwner: string, signer: Signer): Promise<string>;
 export default createZeno;

package/dist/types/contracts/zeno/getAuctions.d.ts

@@ -1,14 +1,17 @@
-import { Signer } from "ethers";
+import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
 import { TokenAmount } from "../../utils/amount";
+import { FundingMode } from "./createAuction";
 /** A ZENO auction, with its amounts in base units. */
 export interface AuctionDetails {
     /** The auction contract address. */
     auctionAddress: string;
     /** The ZENO bond token sold. */
     zenoAddress: string;
+    /** The payment token bidders pay with. */
+    tokenAddress: string;
     /** The issuer receiving the proceeds. */
-    businessAddress: string;
+    issuer: string;
     /** UNIX timestamp (seconds) the auction starts. */
     auctionStartTime: bigint;
     /** UNIX timestamp (seconds) the auction ends. */
@@ -23,19 +26,15 @@ export interface AuctionDetails {
     totalZENOAllocated: TokenAmount;
     /** ZENO still unsold, in ZENO base units. */
     totalZENORemaining: TokenAmount;
-    /** UNIX timestamp (seconds) of the last bid. */
-    lastBidTime: bigint;
-    /** The address of the last bidder. */
-    lastBidder: string;
-    /** The last bid, in payment token base units. */
-    lastBidAmount: TokenAmount;
+    /** How the auction's ZENO is backed by the underlying asset. */
+    fundingMode: FundingMode;
 }
 /**
  * Lists every auction created by the AuctionFactory.
  * @param chainId The chain id.
- * @param signer The signer to read with.
- * @returns One record per auction. Price and bid amounts use the auction's payment token, ZENO amounts the ZENO
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns One record per auction. Price amounts use the auction's payment token, ZENO amounts the ZENO
  * token; decimals and symbols come from the chain config registry and fall back to 18 when the token is not listed.
  */
-declare function getAuctions(chainId: ChainId, signer: Signer): Promise<AuctionDetails[]>;
+declare function getAuctions(chainId: ChainId, provider?: Provider): Promise<AuctionDetails[]>;
 export default getAuctions;

package/dist/types/contracts/zeno/getZenos.d.ts

@@ -1,4 +1,27 @@
-import { Signer } from "ethers";
+import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function getZenos(chainId: ChainId, signer: Signer): Promise<any[]>;
+import { TokenAmount } from "../../utils/amount";
+/** A ZENO bond, with its amounts in base units. */
+export interface ZenoDetails {
+    /** The ZENO bond contract address. */
+    zenoAddress: string;
+    /** UNIX timestamp (seconds) the bond matures. */
+    maturityDate: bigint;
+    /** The bond's ERC20 name, e.g. `ZENO Bond 20270101`. */
+    name: string;
+    /** The bond's ERC20 symbol, e.g. `ZENO-20270101`. */
+    symbol: string;
+    /** ZENO minted over the bond's lifetime, in ZENO base units. */
+    totalMinted: TokenAmount;
+    /** ZENO redeemed for the underlying, in ZENO base units. */
+    totalRedeemed: TokenAmount;
+}
+/**
+ * Lists every ZENO bond created by the ZENOFactory.
+ * @param chainId The chain id.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns One record per bond. Amounts take decimals from the chain config registry and fall back to 18 when the
+ * bond is not listed.
+ */
+declare function getZenos(chainId: ChainId, provider?: Provider): Promise<ZenoDetails[]>;
 export default getZenos;

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
 import RPCLibrary from "./RPCLibrary";
 export * from "./utils/amount";
+export * from "./utils/rpcError";
 export default RPCLibrary;

package/dist/types/pools/rwaVault/checkRedeemEligibility.d.ts

@@ -0,0 +1,15 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+export type RedeemEligibilityReason = "no-draw" | "kyc" | "not-redeemable" | "insufficient-shares" | "other";
+export interface RedeemEligibility {
+    eligible: boolean;
+    reason?: RedeemEligibilityReason;
+    adapter?: string;
+    tokenId?: string;
+}
+/**
+ * Simulates a redeem (via `staticCall`, no transaction sent) to determine
+ * whether `account` can currently redeem an NFT from the RWA vault, reading
+ * the revert name from each simulated call to classify why not, when not.
+ */
+export declare function checkRedeemEligibility(chainId: ChainId, account: string, maxSharesBurn: bigint, provider?: Provider): Promise<RedeemEligibility>;

package/dist/types/pools/stabilityPool/getWithdrawTimelockConfig.d.ts

@@ -0,0 +1,14 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+export interface WithdrawTimelockConfig {
+    /** Seconds after a withdraw request before it's ready. */
+    duration: number;
+    /** Seconds a ready request stays valid before it expires. */
+    delay: number;
+}
+/**
+ * Reads the stability pool's withdraw timelock configuration. The pool's
+ * actual enforced window for a given request is `readyAt + delay` (see
+ * `getWithdrawRequestInfo`'s `readyAt`), not `withdrawTimelock(user).expireAt`.
+ */
+export declare function getWithdrawTimelockConfig(chainId: ChainId, provider?: Provider): Promise<WithdrawTimelockConfig>;

package/dist/types/prices/computeStakingAPY.d.ts

@@ -0,0 +1,2 @@
+/** Simple staking APY = annualized emission value (RAAC x $) over staked value. */
+export declare function computeStakingAPY(weeklyEmissionRAAC: number, stakedAmount: number, stakingTokenPriceUSD: number): number;

package/dist/types/prices/getCurveLPPriceUSD.d.ts

@@ -0,0 +1,3 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+export declare function getCurveLPPriceUSD(chainId: ChainId, token: string, provider?: Provider): Promise<number | null>;

package/dist/types/prices/getPrices.d.ts

@@ -1,12 +1,8 @@
 import { ScaledValue } from "../utils/amount";
-/** Placeholder USD prices per whole token, each scaled by 1e18. */
-export interface Prices {
-    pmUSD: ScaledValue;
-    crvUSD: ScaledValue;
-    raac: ScaledValue;
-}
+/** USD price per whole token, each scaled by 1e18, keyed by lowercase symbol. */
+export type Prices = Record<string, ScaledValue>;
 /**
- * Returns the USD price of each token.
- * @returns The prices, each a USD price per whole token scaled by 1e18.
+ * Returns the static USD price of each known token.
+ * @returns The prices, each a USD price per whole token scaled by 1e18, keyed by lowercase symbol.
  */
 export declare const getPrices: () => Promise<Prices>;

package/dist/types/prices/getStakingTokenPriceUSD.d.ts

@@ -0,0 +1,16 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+export interface StakingTokenLike {
+    stakingToken?: string;
+    stakingTokenSymbol?: string;
+    wrapped?: boolean;
+    wrapper?: string;
+    underlyingSymbol?: string;
+}
+/**
+ * USD value of one unit of a gauge's staking token:
+ *  - wrapped gauges -> ERC4626 wrapper share price (underlying reserve token value),
+ *  - Curve-LP staking tokens -> LP price from pool reserves,
+ *  - otherwise -> static price by symbol.
+ */
+export declare function getStakingTokenPriceUSD(chainId: ChainId, gauge: StakingTokenLike, provider?: Provider): Promise<number>;

package/dist/types/prices/getWrapperPriceUSD.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+/**
+ * USD value of one ERC4626 wrapper share = assets-per-share x underlying price
+ * (e.g. a wrapped RToken share -> its reserve token per share x that token's price).
+ */
+export declare function getWrapperPriceUSD(chainId: ChainId, wrapper: string, underlyingSymbol?: string, provider?: Provider): Promise<number>;

package/dist/types/prices/tokenPricesUSD.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Canonical static USD price per whole token, by lowercase symbol. Testnet
+ * placeholder values - swap for a real oracle/feed in production.
+ */
+export declare const TOKEN_PRICES_USD: Record<string, number>;
+/** Static USD price for a token symbol (0 if unknown). */
+export declare function getTokenPriceUSD(symbol?: string): number;

package/dist/types/scripts/generateErrorCatalogue.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Generates generated/errors.json: one entry per (contract, error) pair, with
+ * an AI-drafted title/message, meant for human review in the PR that
+ * regenerates it. See rpc#16.
+ *
+ * Keeps one entry per contract, keyed `${ContractType}:${selector}` - the
+ * same ContractType key findContract/RpcError already use - rather than
+ * collapsing same-named errors from different contracts into one entry,
+ * which was the root cause of rpc#16's "contract" field problem.
+ *
+ * Needs a checkout of the sibling `contracts` repo (../contracts relative to
+ * this repo) for Solidity source/NatSpec, and ANTHROPIC_API_KEY in .env. Not
+ * part of `npm run build` - run by hand, output committed and reviewed like
+ * any other code.
+ *
+ * Run:
+ *   npm run generate:catalogue
+ */
+import { ContractType } from "../utils/artifacts";
+interface ErrorEntry {
+    contractType: ContractType;
+    contractName: string;
+    sourceName: string;
+    name: string;
+    signature: string;
+    selector: string;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+}
+interface ErrorContext {
+    natspec: string | null;
+    usageSnippets: string[];
+}
+export declare function collectErrors(): ErrorEntry[];
+/**
+ * NatSpec immediately above the `error` declaration, if any, plus every
+ * `revert ErrorName(` usage found anywhere in the file. Errors are not always
+ * declared near their revert sites (RWAVault.sol declares 5 at the end of the
+ * file while they're thrown 300+ lines earlier), so usage is gathered
+ * file-wide, independent of where the declaration sits.
+ */
+export declare function extractContext(sourceName: string, errorName: string): ErrorContext;
+export {};

package/dist/types/typechain-types/@openzeppelin/contracts/index.d.ts

@@ -2,6 +2,8 @@ import type * as access from "./access";
 export type { access };
 import type * as interfaces from "./interfaces";
 export type { interfaces };
+import type * as proxy from "./proxy";
+export type { proxy };
 import type * as token from "./token";
 export type { token };
 import type * as utils from "./utils";

package/dist/types/typechain-types/@openzeppelin/contracts/interfaces/IERC1967.d.ts

@@ -0,0 +1,65 @@
+import type { BaseContract, FunctionFragment, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener } from "../../../common";
+export interface IERC1967Interface extends Interface {
+    getEvent(nameOrSignatureOrTopic: "AdminChanged" | "BeaconUpgraded" | "Upgraded"): EventFragment;
+}
+export declare namespace AdminChangedEvent {
+    type InputTuple = [previousAdmin: AddressLike, newAdmin: AddressLike];
+    type OutputTuple = [previousAdmin: string, newAdmin: string];
+    interface OutputObject {
+        previousAdmin: string;
+        newAdmin: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace BeaconUpgradedEvent {
+    type InputTuple = [beacon: AddressLike];
+    type OutputTuple = [beacon: string];
+    interface OutputObject {
+        beacon: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UpgradedEvent {
+    type InputTuple = [implementation: AddressLike];
+    type OutputTuple = [implementation: string];
+    interface OutputObject {
+        implementation: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IERC1967 extends BaseContract {
+    connect(runner?: ContractRunner | null): IERC1967;
+    waitForDeployment(): Promise<this>;
+    interface: IERC1967Interface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getEvent(key: "AdminChanged"): TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+    getEvent(key: "BeaconUpgraded"): TypedContractEvent<BeaconUpgradedEvent.InputTuple, BeaconUpgradedEvent.OutputTuple, BeaconUpgradedEvent.OutputObject>;
+    getEvent(key: "Upgraded"): TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    filters: {
+        "AdminChanged(address,address)": TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        AdminChanged: TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        "BeaconUpgraded(address)": TypedContractEvent<BeaconUpgradedEvent.InputTuple, BeaconUpgradedEvent.OutputTuple, BeaconUpgradedEvent.OutputObject>;
+        BeaconUpgraded: TypedContractEvent<BeaconUpgradedEvent.InputTuple, BeaconUpgradedEvent.OutputTuple, BeaconUpgradedEvent.OutputObject>;
+        "Upgraded(address)": TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+        Upgraded: TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/@openzeppelin/contracts/interfaces/index.d.ts

@@ -1,5 +1,6 @@
 import type * as draftIerc6093Sol from "./draft-IERC6093.sol";
 export type { draftIerc6093Sol };
 export type { IERC1363 } from "./IERC1363";
+export type { IERC1967 } from "./IERC1967";
 export type { IERC2981 } from "./IERC2981";
 export type { IERC5267 } from "./IERC5267";

package/dist/types/typechain-types/@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.d.ts

@@ -0,0 +1,36 @@
+import type { BaseContract, FunctionFragment, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener } from "../../../../common";
+export interface ERC1967ProxyInterface extends Interface {
+    getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
+}
+export declare namespace UpgradedEvent {
+    type InputTuple = [implementation: AddressLike];
+    type OutputTuple = [implementation: string];
+    interface OutputObject {
+        implementation: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ERC1967Proxy extends BaseContract {
+    connect(runner?: ContractRunner | null): ERC1967Proxy;
+    waitForDeployment(): Promise<this>;
+    interface: ERC1967ProxyInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getEvent(key: "Upgraded"): TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    filters: {
+        "Upgraded(address)": TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+        Upgraded: TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.d.ts

@@ -0,0 +1,20 @@
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../../../common";
+export interface ERC1967UtilsInterface extends Interface {
+}
+export interface ERC1967Utils extends BaseContract {
+    connect(runner?: ContractRunner | null): ERC1967Utils;
+    waitForDeployment(): Promise<this>;
+    interface: ERC1967UtilsInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    filters: {};
+}

package/dist/types/typechain-types/@openzeppelin/contracts/proxy/ERC1967/index.d.ts

@@ -0,0 +1,2 @@
+export type { ERC1967Proxy } from "./ERC1967Proxy";
+export type { ERC1967Utils } from "./ERC1967Utils";

package/dist/types/typechain-types/@openzeppelin/contracts/proxy/Proxy.d.ts

@@ -0,0 +1,20 @@
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../../common";
+export interface ProxyInterface extends Interface {
+}
+export interface Proxy extends BaseContract {
+    connect(runner?: ContractRunner | null): Proxy;
+    waitForDeployment(): Promise<this>;
+    interface: ProxyInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    filters: {};
+}

package/dist/types/typechain-types/@openzeppelin/contracts/proxy/beacon/IBeacon.d.ts

@@ -0,0 +1,25 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface IBeaconInterface extends Interface {
+    getFunction(nameOrSignature: "implementation"): FunctionFragment;
+    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
+}
+export interface IBeacon extends BaseContract {
+    connect(runner?: ContractRunner | null): IBeacon;
+    waitForDeployment(): Promise<this>;
+    interface: IBeaconInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    implementation: TypedContractMethod<[], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "implementation"): TypedContractMethod<[], [string], "view">;
+    filters: {};
+}

package/dist/types/typechain-types/@openzeppelin/contracts/proxy/beacon/index.d.ts

@@ -0,0 +1 @@
+export type { IBeacon } from "./IBeacon";

package/dist/types/typechain-types/@openzeppelin/contracts/proxy/index.d.ts

@@ -0,0 +1,7 @@
+import type * as erc1967 from "./ERC1967";
+export type { erc1967 };
+import type * as beacon from "./beacon";
+export type { beacon };
+import type * as transparent from "./transparent";
+export type { transparent };
+export type { Proxy } from "./Proxy";