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

package/typechain-types/contracts/mocks/core/governance/gauges/MockGaugeController.d.ts

@@ -0,0 +1,29 @@
+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 MockGaugeControllerInterface extends Interface {
+    getFunction(nameOrSignature: "getGaugeWeight" | "getTypeWeight"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getGaugeWeight", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getTypeWeight", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "getGaugeWeight", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTypeWeight", data: BytesLike): Result;
+}
+export interface MockGaugeController extends BaseContract {
+    connect(runner?: ContractRunner | null): MockGaugeController;
+    waitForDeployment(): Promise<this>;
+    interface: MockGaugeControllerInterface;
+    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>;
+    getGaugeWeight: TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getTypeWeight: TypedContractMethod<[arg0: BigNumberish], [bigint], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "getGaugeWeight"): TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getTypeWeight"): TypedContractMethod<[arg0: BigNumberish], [bigint], "view">;
+    filters: {};
+}

package/typechain-types/contracts/mocks/core/governance/gauges/index.d.ts

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

package/typechain-types/contracts/mocks/core/governance/index.d.ts

@@ -0,0 +1,4 @@
+import type * as gauges from "./gauges";
+export type { gauges };
+import type * as proposals from "./proposals";
+export type { proposals };

package/typechain-types/contracts/mocks/core/governance/proposals/TimelockTestTarget.d.ts

@@ -0,0 +1,76 @@
+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 interface TimelockTestTargetInterface extends Interface {
+    getFunction(nameOrSignature: "executeOperation" | "operationExecuted" | "receiveEth" | "setValue" | "value"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "OperationExecuted" | "ValueUpdated"): EventFragment;
+    encodeFunctionData(functionFragment: "executeOperation", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "operationExecuted", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "receiveEth", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setValue", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "value", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "executeOperation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "operationExecuted", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "receiveEth", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setValue", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "value", data: BytesLike): Result;
+}
+export declare namespace OperationExecutedEvent {
+    type InputTuple = [operationId: BytesLike];
+    type OutputTuple = [operationId: string];
+    interface OutputObject {
+        operationId: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace ValueUpdatedEvent {
+    type InputTuple = [oldValue: BigNumberish, newValue: BigNumberish];
+    type OutputTuple = [oldValue: bigint, newValue: bigint];
+    interface OutputObject {
+        oldValue: bigint;
+        newValue: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface TimelockTestTarget extends BaseContract {
+    connect(runner?: ContractRunner | null): TimelockTestTarget;
+    waitForDeployment(): Promise<this>;
+    interface: TimelockTestTargetInterface;
+    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>;
+    executeOperation: TypedContractMethod<[
+        operationId: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    operationExecuted: TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    receiveEth: TypedContractMethod<[], [void], "payable">;
+    setValue: TypedContractMethod<[newValue: BigNumberish], [void], "nonpayable">;
+    value: TypedContractMethod<[], [bigint], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "executeOperation"): TypedContractMethod<[operationId: BytesLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "operationExecuted"): TypedContractMethod<[arg0: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "receiveEth"): TypedContractMethod<[], [void], "payable">;
+    getFunction(nameOrSignature: "setValue"): TypedContractMethod<[newValue: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "value"): TypedContractMethod<[], [bigint], "view">;
+    getEvent(key: "OperationExecuted"): TypedContractEvent<OperationExecutedEvent.InputTuple, OperationExecutedEvent.OutputTuple, OperationExecutedEvent.OutputObject>;
+    getEvent(key: "ValueUpdated"): TypedContractEvent<ValueUpdatedEvent.InputTuple, ValueUpdatedEvent.OutputTuple, ValueUpdatedEvent.OutputObject>;
+    filters: {
+        "OperationExecuted(bytes32)": TypedContractEvent<OperationExecutedEvent.InputTuple, OperationExecutedEvent.OutputTuple, OperationExecutedEvent.OutputObject>;
+        OperationExecuted: TypedContractEvent<OperationExecutedEvent.InputTuple, OperationExecutedEvent.OutputTuple, OperationExecutedEvent.OutputObject>;
+        "ValueUpdated(uint256,uint256)": TypedContractEvent<ValueUpdatedEvent.InputTuple, ValueUpdatedEvent.OutputTuple, ValueUpdatedEvent.OutputObject>;
+        ValueUpdated: TypedContractEvent<ValueUpdatedEvent.InputTuple, ValueUpdatedEvent.OutputTuple, ValueUpdatedEvent.OutputObject>;
+    };
+}

package/typechain-types/contracts/mocks/core/governance/proposals/index.d.ts

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

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

@@ -0,0 +1,14 @@
+import type * as collectors from "./collectors";
+export type { collectors };
+import type * as governance from "./governance";
+export type { governance };
+import type * as oracles from "./oracles";
+export type { oracles };
+import type * as pools from "./pools";
+export type { pools };
+import type * as primitives from "./primitives";
+export type { primitives };
+import type * as tokens from "./tokens";
+export type { tokens };
+import type * as vaults from "./vaults";
+export type { vaults };

package/typechain-types/contracts/mocks/core/oracles/MockFunctionsRouter.sol/IFunctionsRouter.d.ts

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

package/typechain-types/contracts/mocks/core/oracles/MockFunctionsRouter.sol/MockFunctionsRouter.d.ts

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

package/typechain-types/contracts/mocks/core/oracles/MockFunctionsRouter.sol/index.d.ts

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

package/typechain-types/contracts/mocks/core/oracles/MockOracle.d.ts

@@ -0,0 +1,43 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface MockOracleInterface extends Interface {
+    getFunction(nameOrSignature: "donId" | "fulfillRequest"): FunctionFragment;
+    encodeFunctionData(functionFragment: "donId", values?: undefined): string;
+    encodeFunctionData(functionFragment: "fulfillRequest", values: [AddressLike, BytesLike, BytesLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "donId", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "fulfillRequest", data: BytesLike): Result;
+}
+export interface MockOracle extends BaseContract {
+    connect(runner?: ContractRunner | null): MockOracle;
+    waitForDeployment(): Promise<this>;
+    interface: MockOracleInterface;
+    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>;
+    donId: TypedContractMethod<[], [string], "view">;
+    fulfillRequest: TypedContractMethod<[
+        oracleAddress: AddressLike,
+        requestId: BytesLike,
+        response: BytesLike,
+        error: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "donId"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "fulfillRequest"): TypedContractMethod<[
+        oracleAddress: AddressLike,
+        requestId: BytesLike,
+        response: BytesLike,
+        error: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    filters: {};
+}