@raac/rpc 1.0.2-beta.1 → 1.0.2-beta.3

package/typechain-types/contracts/core/tokens/index.d.ts

@@ -0,0 +1,8 @@
+export type { DEToken } from "./DEToken";
+export type { DebtToken } from "./DebtToken";
+export type { IndexToken } from "./IndexToken";
+export type { LPToken } from "./LPToken";
+export type { RAACNFT } from "./RAACNFT";
+export type { RAACToken } from "./RAACToken";
+export type { RToken } from "./RToken";
+export type { VeRAACToken } from "./VeRAACToken";

package/typechain-types/contracts/index.d.ts

@@ -0,0 +1,10 @@
+import type * as core from "./core";
+export type { core };
+import type * as interfaces from "./interfaces";
+export type { interfaces };
+import type * as libraries from "./libraries";
+export type { libraries };
+import type * as mocks from "./mocks";
+export type { mocks };
+import type * as zeno from "./zeno";
+export type { zeno };

package/typechain-types/contracts/interfaces/IERC20.d.ts

@@ -0,0 +1,129 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export interface IERC20Interface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IERC20 extends BaseContract {
+    connect(runner?: ContractRunner | null): IERC20;
+    waitForDeployment(): Promise<this>;
+    interface: IERC20Interface;
+    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>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

package/typechain-types/contracts/interfaces/IHousePrices.d.ts

@@ -0,0 +1,29 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
+export interface IHousePricesInterface extends Interface {
+    getFunction(nameOrSignature: "tokenToHousePrice"): FunctionFragment;
+    encodeFunctionData(functionFragment: "tokenToHousePrice", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "tokenToHousePrice", data: BytesLike): Result;
+}
+export interface IHousePrices extends BaseContract {
+    connect(runner?: ContractRunner | null): IHousePrices;
+    waitForDeployment(): Promise<this>;
+    interface: IHousePricesInterface;
+    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>;
+    tokenToHousePrice: TypedContractMethod<[
+        tokenId: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "tokenToHousePrice"): TypedContractMethod<[tokenId: BigNumberish], [bigint], "view">;
+    filters: {};
+}

package/typechain-types/contracts/interfaces/INFTLiquidator.d.ts

@@ -0,0 +1,73 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
+export interface INFTLiquidatorInterface extends Interface {
+    getFunction(nameOrSignature: "buybackNFT" | "claimAuction" | "liquidateNFT" | "placeBid" | "setStabilityPool"): FunctionFragment;
+    encodeFunctionData(functionFragment: "buybackNFT", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "claimAuction", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "liquidateNFT", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "placeBid", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setStabilityPool", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "buybackNFT", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimAuction", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "liquidateNFT", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "placeBid", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setStabilityPool", data: BytesLike): Result;
+}
+export interface INFTLiquidator extends BaseContract {
+    connect(runner?: ContractRunner | null): INFTLiquidator;
+    waitForDeployment(): Promise<this>;
+    interface: INFTLiquidatorInterface;
+    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>;
+    buybackNFT: TypedContractMethod<[
+        tokenId: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    claimAuction: TypedContractMethod<[
+        tokenId: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    liquidateNFT: TypedContractMethod<[
+        tokenId: BigNumberish,
+        debt: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    placeBid: TypedContractMethod<[
+        tokenId: BigNumberish,
+        bidAmount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setStabilityPool: TypedContractMethod<[
+        _stabilityPool: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "buybackNFT"): TypedContractMethod<[tokenId: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "claimAuction"): TypedContractMethod<[tokenId: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "liquidateNFT"): TypedContractMethod<[
+        tokenId: BigNumberish,
+        debt: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "placeBid"): TypedContractMethod<[
+        tokenId: BigNumberish,
+        bidAmount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setStabilityPool"): TypedContractMethod<[_stabilityPool: AddressLike], [void], "nonpayable">;
+    filters: {};
+}

package/typechain-types/contracts/interfaces/IPoolManager.d.ts

@@ -0,0 +1,37 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
+export interface IPoolManagerInterface extends Interface {
+    getFunction(nameOrSignature: "divest" | "generateYield" | "getAvailableBalance" | "invest"): FunctionFragment;
+    encodeFunctionData(functionFragment: "divest", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "generateYield", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getAvailableBalance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "invest", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "divest", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "generateYield", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAvailableBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "invest", data: BytesLike): Result;
+}
+export interface IPoolManager extends BaseContract {
+    connect(runner?: ContractRunner | null): IPoolManager;
+    waitForDeployment(): Promise<this>;
+    interface: IPoolManagerInterface;
+    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>;
+    divest: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    generateYield: TypedContractMethod<[], [void], "nonpayable">;
+    getAvailableBalance: TypedContractMethod<[], [bigint], "view">;
+    invest: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "divest"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "generateYield"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "getAvailableBalance"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "invest"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    filters: {};
+}

package/typechain-types/contracts/interfaces/IReserveAllocationLibraryMock.d.ts

@@ -0,0 +1,164 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
+export declare namespace ReserveLibrary {
+    type ReserveRateDataStruct = {
+        currentLiquidityRate: BigNumberish;
+        currentUsageRate: BigNumberish;
+        primeRate: BigNumberish;
+        baseRate: BigNumberish;
+        optimalRate: BigNumberish;
+        maxRate: BigNumberish;
+        optimalUtilizationRate: BigNumberish;
+        protocolFeeRate: BigNumberish;
+    };
+    type ReserveRateDataStructOutput = [
+        currentLiquidityRate: bigint,
+        currentUsageRate: bigint,
+        primeRate: bigint,
+        baseRate: bigint,
+        optimalRate: bigint,
+        maxRate: bigint,
+        optimalUtilizationRate: bigint,
+        protocolFeeRate: bigint
+    ] & {
+        currentLiquidityRate: bigint;
+        currentUsageRate: bigint;
+        primeRate: bigint;
+        baseRate: bigint;
+        optimalRate: bigint;
+        maxRate: bigint;
+        optimalUtilizationRate: bigint;
+        protocolFeeRate: bigint;
+    };
+    type ReserveDataStruct = {
+        reserveRTokenAddress: AddressLike;
+        reserveAssetAddress: AddressLike;
+        reserveDebtTokenAddress: AddressLike;
+        totalLiquidity: BigNumberish;
+        totalUsage: BigNumberish;
+        liquidityIndex: BigNumberish;
+        usageIndex: BigNumberish;
+        lastUpdateTimestamp: BigNumberish;
+    };
+    type ReserveDataStructOutput = [
+        reserveRTokenAddress: string,
+        reserveAssetAddress: string,
+        reserveDebtTokenAddress: string,
+        totalLiquidity: bigint,
+        totalUsage: bigint,
+        liquidityIndex: bigint,
+        usageIndex: bigint,
+        lastUpdateTimestamp: bigint
+    ] & {
+        reserveRTokenAddress: string;
+        reserveAssetAddress: string;
+        reserveDebtTokenAddress: string;
+        totalLiquidity: bigint;
+        totalUsage: bigint;
+        liquidityIndex: bigint;
+        usageIndex: bigint;
+        lastUpdateTimestamp: bigint;
+    };
+}
+export interface IReserveAllocationLibraryMockInterface extends Interface {
+    getFunction(nameOrSignature: "addLiquidity" | "allocateFunds" | "borrow" | "calculateUtilizationRate" | "getRateData" | "getReserveData" | "repay" | "setPrimeRate"): FunctionFragment;
+    encodeFunctionData(functionFragment: "addLiquidity", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "allocateFunds", values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: "borrow", values: [BigNumberish, AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "calculateUtilizationRate", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getRateData", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getReserveData", values?: undefined): string;
+    encodeFunctionData(functionFragment: "repay", values: [BigNumberish, AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "setPrimeRate", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "addLiquidity", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allocateFunds", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "borrow", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculateUtilizationRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRateData", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getReserveData", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "repay", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setPrimeRate", data: BytesLike): Result;
+}
+export interface IReserveAllocationLibraryMock extends BaseContract {
+    connect(runner?: ContractRunner | null): IReserveAllocationLibraryMock;
+    waitForDeployment(): Promise<this>;
+    interface: IReserveAllocationLibraryMockInterface;
+    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>;
+    addLiquidity: TypedContractMethod<[
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    allocateFunds: TypedContractMethod<[
+        amount: BigNumberish,
+        recipient: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    borrow: TypedContractMethod<[
+        amount: BigNumberish,
+        user: AddressLike,
+        onBehalfOf: AddressLike
+    ], [
+        [bigint, bigint]
+    ], "nonpayable">;
+    calculateUtilizationRate: TypedContractMethod<[], [bigint], "view">;
+    getRateData: TypedContractMethod<[
+    ], [
+        ReserveLibrary.ReserveRateDataStructOutput
+    ], "view">;
+    getReserveData: TypedContractMethod<[
+    ], [
+        ReserveLibrary.ReserveDataStructOutput
+    ], "view">;
+    repay: TypedContractMethod<[
+        amount: BigNumberish,
+        user: AddressLike,
+        onBehalfOf: AddressLike
+    ], [
+        [bigint, bigint]
+    ], "nonpayable">;
+    setPrimeRate: TypedContractMethod<[
+        newPrimeRate: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "addLiquidity"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "allocateFunds"): TypedContractMethod<[
+        amount: BigNumberish,
+        recipient: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "borrow"): TypedContractMethod<[
+        amount: BigNumberish,
+        user: AddressLike,
+        onBehalfOf: AddressLike
+    ], [
+        [bigint, bigint]
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "calculateUtilizationRate"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "getRateData"): TypedContractMethod<[
+    ], [
+        ReserveLibrary.ReserveRateDataStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "getReserveData"): TypedContractMethod<[], [ReserveLibrary.ReserveDataStructOutput], "view">;
+    getFunction(nameOrSignature: "repay"): TypedContractMethod<[
+        amount: BigNumberish,
+        user: AddressLike,
+        onBehalfOf: AddressLike
+    ], [
+        [bigint, bigint]
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setPrimeRate"): TypedContractMethod<[newPrimeRate: BigNumberish], [void], "nonpayable">;
+    filters: {};
+}

package/typechain-types/contracts/interfaces/IUSDC.d.ts

@@ -0,0 +1,129 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export interface IUSDCInterface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IUSDC extends BaseContract {
+    connect(runner?: ContractRunner | null): IUSDC;
+    waitForDeployment(): Promise<this>;
+    interface: IUSDCInterface;
+    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>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        sender: AddressLike,
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

package/typechain-types/contracts/interfaces/IveRAACDistributor.d.ts

@@ -0,0 +1,59 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
+export interface IveRAACDistributorInterface extends Interface {
+    getFunction(nameOrSignature: "authorizePool" | "calculateReward" | "claimRewards" | "distributeRewards" | "getPendingRewards" | "updateRewards"): FunctionFragment;
+    encodeFunctionData(functionFragment: "authorizePool", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "calculateReward", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "claimRewards", values?: undefined): string;
+    encodeFunctionData(functionFragment: "distributeRewards", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getPendingRewards", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "updateRewards", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "authorizePool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculateReward", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimRewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "distributeRewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPendingRewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateRewards", data: BytesLike): Result;
+}
+export interface IveRAACDistributor extends BaseContract {
+    connect(runner?: ContractRunner | null): IveRAACDistributor;
+    waitForDeployment(): Promise<this>;
+    interface: IveRAACDistributorInterface;
+    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>;
+    authorizePool: TypedContractMethod<[pool: AddressLike], [void], "nonpayable">;
+    calculateReward: TypedContractMethod<[
+        amount: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    claimRewards: TypedContractMethod<[], [void], "nonpayable">;
+    distributeRewards: TypedContractMethod<[
+        user: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getPendingRewards: TypedContractMethod<[user: AddressLike], [bigint], "view">;
+    updateRewards: TypedContractMethod<[user: AddressLike], [void], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "authorizePool"): TypedContractMethod<[pool: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "calculateReward"): TypedContractMethod<[amount: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "claimRewards"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "distributeRewards"): TypedContractMethod<[
+        user: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "getPendingRewards"): TypedContractMethod<[user: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "updateRewards"): TypedContractMethod<[user: AddressLike], [void], "nonpayable">;
+    filters: {};
+}