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

package/typechain-types/contracts/interfaces/core/minters/RAACReleaseOrchestrator/IReleaseOrchestrator.d.ts

@@ -0,0 +1,237 @@
+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 declare namespace IReleaseOrchestrator {
+    type VestingScheduleStruct = {
+        totalAmount: BigNumberish;
+        releasedAmount: BigNumberish;
+        startTime: BigNumberish;
+        duration: BigNumberish;
+        lastClaimTime: BigNumberish;
+        initialized: boolean;
+    };
+    type VestingScheduleStructOutput = [
+        totalAmount: bigint,
+        releasedAmount: bigint,
+        startTime: bigint,
+        duration: bigint,
+        lastClaimTime: bigint,
+        initialized: boolean
+    ] & {
+        totalAmount: bigint;
+        releasedAmount: bigint;
+        startTime: bigint;
+        duration: bigint;
+        lastClaimTime: bigint;
+        initialized: boolean;
+    };
+}
+export interface IReleaseOrchestratorInterface extends Interface {
+    getFunction(nameOrSignature: "createVestingSchedule" | "emergencyRevoke" | "getCategoryDetails" | "getTotalAllocation" | "getVestingSchedule" | "release" | "setEmergencyShutdown" | "updateCategoryAllocation"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "CategoryAllocationUpdated" | "EmergencyShutdown" | "EmergencyWithdraw" | "TokensReleased" | "VestingScheduleCreated" | "VestingScheduleRevoked"): EventFragment;
+    encodeFunctionData(functionFragment: "createVestingSchedule", values: [AddressLike, BytesLike, BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "emergencyRevoke", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getCategoryDetails", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "getTotalAllocation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getVestingSchedule", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "release", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setEmergencyShutdown", values: [boolean]): string;
+    encodeFunctionData(functionFragment: "updateCategoryAllocation", values: [BytesLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "createVestingSchedule", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "emergencyRevoke", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCategoryDetails", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTotalAllocation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getVestingSchedule", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "release", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setEmergencyShutdown", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateCategoryAllocation", data: BytesLike): Result;
+}
+export declare namespace CategoryAllocationUpdatedEvent {
+    type InputTuple = [category: BytesLike, newAllocation: BigNumberish];
+    type OutputTuple = [category: string, newAllocation: bigint];
+    interface OutputObject {
+        category: string;
+        newAllocation: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace EmergencyShutdownEvent {
+    type InputTuple = [caller: AddressLike, paused: boolean];
+    type OutputTuple = [caller: string, paused: boolean];
+    interface OutputObject {
+        caller: string;
+        paused: boolean;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace EmergencyWithdrawEvent {
+    type InputTuple = [beneficiary: AddressLike, amount: BigNumberish];
+    type OutputTuple = [beneficiary: string, amount: bigint];
+    interface OutputObject {
+        beneficiary: string;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TokensReleasedEvent {
+    type InputTuple = [beneficiary: AddressLike, amount: BigNumberish];
+    type OutputTuple = [beneficiary: string, amount: bigint];
+    interface OutputObject {
+        beneficiary: string;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace VestingScheduleCreatedEvent {
+    type InputTuple = [
+        beneficiary: AddressLike,
+        category: BytesLike,
+        amount: BigNumberish,
+        startTime: BigNumberish
+    ];
+    type OutputTuple = [
+        beneficiary: string,
+        category: string,
+        amount: bigint,
+        startTime: bigint
+    ];
+    interface OutputObject {
+        beneficiary: string;
+        category: string;
+        amount: bigint;
+        startTime: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace VestingScheduleRevokedEvent {
+    type InputTuple = [beneficiary: AddressLike];
+    type OutputTuple = [beneficiary: string];
+    interface OutputObject {
+        beneficiary: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IReleaseOrchestrator extends BaseContract {
+    connect(runner?: ContractRunner | null): IReleaseOrchestrator;
+    waitForDeployment(): Promise<this>;
+    interface: IReleaseOrchestratorInterface;
+    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>;
+    createVestingSchedule: TypedContractMethod<[
+        beneficiary: AddressLike,
+        category: BytesLike,
+        amount: BigNumberish,
+        startTime: BigNumberish,
+        vestingDuration: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    emergencyRevoke: TypedContractMethod<[
+        beneficiary: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getCategoryDetails: TypedContractMethod<[
+        category: BytesLike
+    ], [
+        [bigint, bigint] & {
+            allocation: bigint;
+            used: bigint;
+        }
+    ], "view">;
+    getTotalAllocation: TypedContractMethod<[], [bigint], "view">;
+    getVestingSchedule: TypedContractMethod<[
+        beneficiary: AddressLike
+    ], [
+        IReleaseOrchestrator.VestingScheduleStructOutput
+    ], "view">;
+    release: TypedContractMethod<[], [void], "nonpayable">;
+    setEmergencyShutdown: TypedContractMethod<[
+        paused: boolean
+    ], [
+        void
+    ], "nonpayable">;
+    updateCategoryAllocation: TypedContractMethod<[
+        category: BytesLike,
+        newAllocation: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "createVestingSchedule"): TypedContractMethod<[
+        beneficiary: AddressLike,
+        category: BytesLike,
+        amount: BigNumberish,
+        startTime: BigNumberish,
+        vestingDuration: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "emergencyRevoke"): TypedContractMethod<[beneficiary: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "getCategoryDetails"): TypedContractMethod<[
+        category: BytesLike
+    ], [
+        [bigint, bigint] & {
+            allocation: bigint;
+            used: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "getTotalAllocation"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "getVestingSchedule"): TypedContractMethod<[
+        beneficiary: AddressLike
+    ], [
+        IReleaseOrchestrator.VestingScheduleStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "release"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setEmergencyShutdown"): TypedContractMethod<[paused: boolean], [void], "nonpayable">;
+    getFunction(nameOrSignature: "updateCategoryAllocation"): TypedContractMethod<[
+        category: BytesLike,
+        newAllocation: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "CategoryAllocationUpdated"): TypedContractEvent<CategoryAllocationUpdatedEvent.InputTuple, CategoryAllocationUpdatedEvent.OutputTuple, CategoryAllocationUpdatedEvent.OutputObject>;
+    getEvent(key: "EmergencyShutdown"): TypedContractEvent<EmergencyShutdownEvent.InputTuple, EmergencyShutdownEvent.OutputTuple, EmergencyShutdownEvent.OutputObject>;
+    getEvent(key: "EmergencyWithdraw"): TypedContractEvent<EmergencyWithdrawEvent.InputTuple, EmergencyWithdrawEvent.OutputTuple, EmergencyWithdrawEvent.OutputObject>;
+    getEvent(key: "TokensReleased"): TypedContractEvent<TokensReleasedEvent.InputTuple, TokensReleasedEvent.OutputTuple, TokensReleasedEvent.OutputObject>;
+    getEvent(key: "VestingScheduleCreated"): TypedContractEvent<VestingScheduleCreatedEvent.InputTuple, VestingScheduleCreatedEvent.OutputTuple, VestingScheduleCreatedEvent.OutputObject>;
+    getEvent(key: "VestingScheduleRevoked"): TypedContractEvent<VestingScheduleRevokedEvent.InputTuple, VestingScheduleRevokedEvent.OutputTuple, VestingScheduleRevokedEvent.OutputObject>;
+    filters: {
+        "CategoryAllocationUpdated(bytes32,uint256)": TypedContractEvent<CategoryAllocationUpdatedEvent.InputTuple, CategoryAllocationUpdatedEvent.OutputTuple, CategoryAllocationUpdatedEvent.OutputObject>;
+        CategoryAllocationUpdated: TypedContractEvent<CategoryAllocationUpdatedEvent.InputTuple, CategoryAllocationUpdatedEvent.OutputTuple, CategoryAllocationUpdatedEvent.OutputObject>;
+        "EmergencyShutdown(address,bool)": TypedContractEvent<EmergencyShutdownEvent.InputTuple, EmergencyShutdownEvent.OutputTuple, EmergencyShutdownEvent.OutputObject>;
+        EmergencyShutdown: TypedContractEvent<EmergencyShutdownEvent.InputTuple, EmergencyShutdownEvent.OutputTuple, EmergencyShutdownEvent.OutputObject>;
+        "EmergencyWithdraw(address,uint256)": TypedContractEvent<EmergencyWithdrawEvent.InputTuple, EmergencyWithdrawEvent.OutputTuple, EmergencyWithdrawEvent.OutputObject>;
+        EmergencyWithdraw: TypedContractEvent<EmergencyWithdrawEvent.InputTuple, EmergencyWithdrawEvent.OutputTuple, EmergencyWithdrawEvent.OutputObject>;
+        "TokensReleased(address,uint256)": TypedContractEvent<TokensReleasedEvent.InputTuple, TokensReleasedEvent.OutputTuple, TokensReleasedEvent.OutputObject>;
+        TokensReleased: TypedContractEvent<TokensReleasedEvent.InputTuple, TokensReleasedEvent.OutputTuple, TokensReleasedEvent.OutputObject>;
+        "VestingScheduleCreated(address,bytes32,uint256,uint256)": TypedContractEvent<VestingScheduleCreatedEvent.InputTuple, VestingScheduleCreatedEvent.OutputTuple, VestingScheduleCreatedEvent.OutputObject>;
+        VestingScheduleCreated: TypedContractEvent<VestingScheduleCreatedEvent.InputTuple, VestingScheduleCreatedEvent.OutputTuple, VestingScheduleCreatedEvent.OutputObject>;
+        "VestingScheduleRevoked(address)": TypedContractEvent<VestingScheduleRevokedEvent.InputTuple, VestingScheduleRevokedEvent.OutputTuple, VestingScheduleRevokedEvent.OutputObject>;
+        VestingScheduleRevoked: TypedContractEvent<VestingScheduleRevokedEvent.InputTuple, VestingScheduleRevokedEvent.OutputTuple, VestingScheduleRevokedEvent.OutputObject>;
+    };
+}

package/typechain-types/contracts/interfaces/core/minters/RAACReleaseOrchestrator/index.d.ts

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

package/typechain-types/contracts/interfaces/core/minters/index.d.ts

@@ -0,0 +1,4 @@
+import type * as raacMinter from "./RAACMinter";
+export type { raacMinter };
+import type * as raacReleaseOrchestrator from "./RAACReleaseOrchestrator";
+export type { raacReleaseOrchestrator };

package/typechain-types/contracts/interfaces/core/oracles/IBaseVRFv2Consumer.d.ts

@@ -0,0 +1,86 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export declare namespace IBaseVRFv2Consumer {
+    type RequestStatusStruct = {
+        fulfilled: boolean;
+        exists: boolean;
+        randomWords: BigNumberish[];
+    };
+    type RequestStatusStructOutput = [
+        fulfilled: boolean,
+        exists: boolean,
+        randomWords: bigint[]
+    ] & {
+        fulfilled: boolean;
+        exists: boolean;
+        randomWords: bigint[];
+    };
+}
+export interface IBaseVRFv2ConsumerInterface extends Interface {
+    getFunction(nameOrSignature: "getRequestStatus" | "requestRandomWords"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "RequestFulfilled" | "RequestSent"): EventFragment;
+    encodeFunctionData(functionFragment: "getRequestStatus", values?: undefined): string;
+    encodeFunctionData(functionFragment: "requestRandomWords", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "getRequestStatus", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "requestRandomWords", data: BytesLike): Result;
+}
+export declare namespace RequestFulfilledEvent {
+    type InputTuple = [
+        requestId: BigNumberish,
+        randomWords: BigNumberish[]
+    ];
+    type OutputTuple = [requestId: bigint, randomWords: bigint[]];
+    interface OutputObject {
+        requestId: bigint;
+        randomWords: bigint[];
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RequestSentEvent {
+    type InputTuple = [requestId: BigNumberish, numWords: BigNumberish];
+    type OutputTuple = [requestId: bigint, numWords: bigint];
+    interface OutputObject {
+        requestId: bigint;
+        numWords: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IBaseVRFv2Consumer extends BaseContract {
+    connect(runner?: ContractRunner | null): IBaseVRFv2Consumer;
+    waitForDeployment(): Promise<this>;
+    interface: IBaseVRFv2ConsumerInterface;
+    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>;
+    getRequestStatus: TypedContractMethod<[
+    ], [
+        IBaseVRFv2Consumer.RequestStatusStructOutput
+    ], "view">;
+    requestRandomWords: TypedContractMethod<[], [bigint], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "getRequestStatus"): TypedContractMethod<[
+    ], [
+        IBaseVRFv2Consumer.RequestStatusStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "requestRandomWords"): TypedContractMethod<[], [bigint], "nonpayable">;
+    getEvent(key: "RequestFulfilled"): TypedContractEvent<RequestFulfilledEvent.InputTuple, RequestFulfilledEvent.OutputTuple, RequestFulfilledEvent.OutputObject>;
+    getEvent(key: "RequestSent"): TypedContractEvent<RequestSentEvent.InputTuple, RequestSentEvent.OutputTuple, RequestSentEvent.OutputObject>;
+    filters: {
+        "RequestFulfilled(uint256,uint256[])": TypedContractEvent<RequestFulfilledEvent.InputTuple, RequestFulfilledEvent.OutputTuple, RequestFulfilledEvent.OutputObject>;
+        RequestFulfilled: TypedContractEvent<RequestFulfilledEvent.InputTuple, RequestFulfilledEvent.OutputTuple, RequestFulfilledEvent.OutputObject>;
+        "RequestSent(uint256,uint32)": TypedContractEvent<RequestSentEvent.InputTuple, RequestSentEvent.OutputTuple, RequestSentEvent.OutputObject>;
+        RequestSent: TypedContractEvent<RequestSentEvent.InputTuple, RequestSentEvent.OutputTuple, RequestSentEvent.OutputObject>;
+    };
+}

package/typechain-types/contracts/interfaces/core/oracles/IRAACHousePrices.d.ts

@@ -0,0 +1,110 @@
+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 IRAACHousePricesInterface extends Interface {
+    getFunction(nameOrSignature: "MAX_PRICE_AGE" | "UPDATE_INTERVAL" | "getLatestPrice" | "lastUpdateTimestamp" | "oracle" | "setHousePrice" | "setOracle" | "tokenLastUpdateTimestamp" | "tokenToHousePrice" | "updatePriceFromOracle"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "PriceUpdated"): EventFragment;
+    encodeFunctionData(functionFragment: "MAX_PRICE_AGE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "UPDATE_INTERVAL", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getLatestPrice", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "lastUpdateTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "oracle", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setHousePrice", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setOracle", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "tokenLastUpdateTimestamp", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "tokenToHousePrice", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "updatePriceFromOracle", values: [BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "MAX_PRICE_AGE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "UPDATE_INTERVAL", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLatestPrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lastUpdateTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "oracle", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setHousePrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setOracle", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tokenLastUpdateTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tokenToHousePrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updatePriceFromOracle", data: BytesLike): Result;
+}
+export declare namespace PriceUpdatedEvent {
+    type InputTuple = [tokenId: BigNumberish, newPrice: BigNumberish];
+    type OutputTuple = [tokenId: bigint, newPrice: bigint];
+    interface OutputObject {
+        tokenId: bigint;
+        newPrice: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IRAACHousePrices extends BaseContract {
+    connect(runner?: ContractRunner | null): IRAACHousePrices;
+    waitForDeployment(): Promise<this>;
+    interface: IRAACHousePricesInterface;
+    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>;
+    MAX_PRICE_AGE: TypedContractMethod<[], [bigint], "view">;
+    UPDATE_INTERVAL: TypedContractMethod<[], [bigint], "view">;
+    getLatestPrice: TypedContractMethod<[
+        _tokenId: BigNumberish
+    ], [
+        [bigint, bigint]
+    ], "view">;
+    lastUpdateTimestamp: TypedContractMethod<[], [bigint], "view">;
+    oracle: TypedContractMethod<[], [string], "view">;
+    setHousePrice: TypedContractMethod<[
+        _tokenId: BigNumberish,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setOracle: TypedContractMethod<[_oracle: AddressLike], [void], "nonpayable">;
+    tokenLastUpdateTimestamp: TypedContractMethod<[
+        _tokenId: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    tokenToHousePrice: TypedContractMethod<[
+        _tokenId: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    updatePriceFromOracle: TypedContractMethod<[
+        _tokenId: BigNumberish,
+        _newPrice: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "MAX_PRICE_AGE"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "UPDATE_INTERVAL"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "getLatestPrice"): TypedContractMethod<[_tokenId: BigNumberish], [[bigint, bigint]], "view">;
+    getFunction(nameOrSignature: "lastUpdateTimestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "oracle"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "setHousePrice"): TypedContractMethod<[
+        _tokenId: BigNumberish,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setOracle"): TypedContractMethod<[_oracle: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "tokenLastUpdateTimestamp"): TypedContractMethod<[_tokenId: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "tokenToHousePrice"): TypedContractMethod<[_tokenId: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "updatePriceFromOracle"): TypedContractMethod<[
+        _tokenId: BigNumberish,
+        _newPrice: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "PriceUpdated"): TypedContractEvent<PriceUpdatedEvent.InputTuple, PriceUpdatedEvent.OutputTuple, PriceUpdatedEvent.OutputObject>;
+    filters: {
+        "PriceUpdated(uint256,uint256)": TypedContractEvent<PriceUpdatedEvent.InputTuple, PriceUpdatedEvent.OutputTuple, PriceUpdatedEvent.OutputObject>;
+        PriceUpdated: TypedContractEvent<PriceUpdatedEvent.InputTuple, PriceUpdatedEvent.OutputTuple, PriceUpdatedEvent.OutputObject>;
+    };
+}

package/typechain-types/contracts/interfaces/core/oracles/index.d.ts

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

package/typechain-types/contracts/interfaces/core/pools/ILiquidityPool.d.ts

@@ -0,0 +1,185 @@
+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 ILiquidityPoolInterface extends Interface {
+    getFunction(nameOrSignature: "A" | "add_liquidity" | "balances" | "coins" | "exchange" | "fee" | "getExchangeRate" | "getTotalLiquidity" | "getTotalValueLocked" | "getUserLiquidity" | "get_dy" | "remove_liquidity" | "remove_liquidity_one_coin"): FunctionFragment;
+    encodeFunctionData(functionFragment: "A", values?: undefined): string;
+    encodeFunctionData(functionFragment: "add_liquidity", values: [[BigNumberish, BigNumberish], BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balances", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "coins", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "exchange", values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "fee", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getExchangeRate", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getTotalLiquidity", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getTotalValueLocked", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getUserLiquidity", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "get_dy", values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "remove_liquidity", values: [BigNumberish, [BigNumberish, BigNumberish]]): string;
+    encodeFunctionData(functionFragment: "remove_liquidity_one_coin", values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "A", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "add_liquidity", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balances", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "coins", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "exchange", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "fee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getExchangeRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTotalLiquidity", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTotalValueLocked", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getUserLiquidity", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "get_dy", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "remove_liquidity", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "remove_liquidity_one_coin", data: BytesLike): Result;
+}
+export interface ILiquidityPool extends BaseContract {
+    connect(runner?: ContractRunner | null): ILiquidityPool;
+    waitForDeployment(): Promise<this>;
+    interface: ILiquidityPoolInterface;
+    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>;
+    A: TypedContractMethod<[], [bigint], "view">;
+    add_liquidity: TypedContractMethod<[
+        amounts: [BigNumberish, BigNumberish],
+        min_mint_amount: BigNumberish
+    ], [
+        bigint
+    ], "nonpayable">;
+    balances: TypedContractMethod<[i: BigNumberish], [bigint], "view">;
+    coins: TypedContractMethod<[i: BigNumberish], [string], "view">;
+    exchange: TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish,
+        min_dy: BigNumberish
+    ], [
+        bigint
+    ], "nonpayable">;
+    fee: TypedContractMethod<[], [bigint], "view">;
+    getExchangeRate: TypedContractMethod<[
+        _pairedToken: AddressLike
+    ], [
+        [bigint, bigint] & {
+            raacPerPaired: bigint;
+            pairedPerRaac: bigint;
+        }
+    ], "view">;
+    getTotalLiquidity: TypedContractMethod<[
+        _pairedToken: AddressLike
+    ], [
+        [bigint, bigint] & {
+            raacLiquidity: bigint;
+            pairedLiquidity: bigint;
+        }
+    ], "view">;
+    getTotalValueLocked: TypedContractMethod<[], [bigint], "view">;
+    getUserLiquidity: TypedContractMethod<[
+        _pairedToken: AddressLike,
+        _user: AddressLike
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            raacLiquidity: bigint;
+            pairedLiquidity: bigint;
+            lpAmount: bigint;
+        }
+    ], "view">;
+    get_dy: TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    remove_liquidity: TypedContractMethod<[
+        _amount: BigNumberish,
+        min_amounts: [BigNumberish, BigNumberish]
+    ], [
+        [bigint, bigint]
+    ], "nonpayable">;
+    remove_liquidity_one_coin: TypedContractMethod<[
+        token_amount: BigNumberish,
+        i: BigNumberish,
+        min_amount: BigNumberish
+    ], [
+        bigint
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "A"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "add_liquidity"): TypedContractMethod<[
+        amounts: [BigNumberish, BigNumberish],
+        min_mint_amount: BigNumberish
+    ], [
+        bigint
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balances"): TypedContractMethod<[i: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "coins"): TypedContractMethod<[i: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "exchange"): TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish,
+        min_dy: BigNumberish
+    ], [
+        bigint
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "fee"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "getExchangeRate"): TypedContractMethod<[
+        _pairedToken: AddressLike
+    ], [
+        [bigint, bigint] & {
+            raacPerPaired: bigint;
+            pairedPerRaac: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "getTotalLiquidity"): TypedContractMethod<[
+        _pairedToken: AddressLike
+    ], [
+        [bigint, bigint] & {
+            raacLiquidity: bigint;
+            pairedLiquidity: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "getTotalValueLocked"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "getUserLiquidity"): TypedContractMethod<[
+        _pairedToken: AddressLike,
+        _user: AddressLike
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            raacLiquidity: bigint;
+            pairedLiquidity: bigint;
+            lpAmount: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "get_dy"): TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "remove_liquidity"): TypedContractMethod<[
+        _amount: BigNumberish,
+        min_amounts: [BigNumberish, BigNumberish]
+    ], [
+        [bigint, bigint]
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "remove_liquidity_one_coin"): TypedContractMethod<[
+        token_amount: BigNumberish,
+        i: BigNumberish,
+        min_amount: BigNumberish
+    ], [
+        bigint
+    ], "nonpayable">;
+    filters: {};
+}