@raac/rpc 1.0.0 → 1.0.1

package/dist/types/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/dist/types/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: {};
+}

package/dist/types/typechain-types/contracts/interfaces/core/collectors/IFeeCollector.d.ts

@@ -0,0 +1,300 @@
+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 IFeeCollector {
+    type FeeTypeStruct = {
+        veRAACShare: BigNumberish;
+        burnShare: BigNumberish;
+        repairShare: BigNumberish;
+        treasuryShare: BigNumberish;
+    };
+    type FeeTypeStructOutput = [
+        veRAACShare: bigint,
+        burnShare: bigint,
+        repairShare: bigint,
+        treasuryShare: bigint
+    ] & {
+        veRAACShare: bigint;
+        burnShare: bigint;
+        repairShare: bigint;
+        treasuryShare: bigint;
+    };
+    type CollectedFeesStruct = {
+        protocolFees: BigNumberish;
+        lendingFees: BigNumberish;
+        performanceFees: BigNumberish;
+        insuranceFees: BigNumberish;
+        mintRedeemFees: BigNumberish;
+        vaultFees: BigNumberish;
+        swapTaxes: BigNumberish;
+        nftRoyalties: BigNumberish;
+    };
+    type CollectedFeesStructOutput = [
+        protocolFees: bigint,
+        lendingFees: bigint,
+        performanceFees: bigint,
+        insuranceFees: bigint,
+        mintRedeemFees: bigint,
+        vaultFees: bigint,
+        swapTaxes: bigint,
+        nftRoyalties: bigint
+    ] & {
+        protocolFees: bigint;
+        lendingFees: bigint;
+        performanceFees: bigint;
+        insuranceFees: bigint;
+        mintRedeemFees: bigint;
+        vaultFees: bigint;
+        swapTaxes: bigint;
+        nftRoyalties: bigint;
+    };
+}
+export interface IFeeCollectorInterface extends Interface {
+    getFunction(nameOrSignature: "claimRewards" | "collectFee" | "distributeCollectedFees" | "emergencyWithdraw" | "getCollectedFees" | "getFeeType" | "getPendingRewards" | "setRepairFund" | "setTreasury" | "updateFeeType"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "DistributionParametersUpdated" | "EmergencyWithdrawal" | "FeeCollected" | "FeeDistributed" | "FeeTypeUpdated" | "RepairFundUpdated" | "RewardClaimed" | "TreasuryUpdated"): EventFragment;
+    encodeFunctionData(functionFragment: "claimRewards", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "collectFee", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "distributeCollectedFees", values?: undefined): string;
+    encodeFunctionData(functionFragment: "emergencyWithdraw", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getCollectedFees", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getFeeType", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getPendingRewards", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setRepairFund", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setTreasury", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "updateFeeType", values: [BigNumberish, IFeeCollector.FeeTypeStruct]): string;
+    decodeFunctionResult(functionFragment: "claimRewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "collectFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "distributeCollectedFees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "emergencyWithdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCollectedFees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getFeeType", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPendingRewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setRepairFund", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTreasury", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateFeeType", data: BytesLike): Result;
+}
+export declare namespace DistributionParametersUpdatedEvent {
+    type InputTuple = [
+        feeType: BigNumberish,
+        newParameters: IFeeCollector.FeeTypeStruct
+    ];
+    type OutputTuple = [
+        feeType: bigint,
+        newParameters: IFeeCollector.FeeTypeStructOutput
+    ];
+    interface OutputObject {
+        feeType: bigint;
+        newParameters: IFeeCollector.FeeTypeStructOutput;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace EmergencyWithdrawalEvent {
+    type InputTuple = [token: AddressLike, amount: BigNumberish];
+    type OutputTuple = [token: string, amount: bigint];
+    interface OutputObject {
+        token: string;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace FeeCollectedEvent {
+    type InputTuple = [feeType: BigNumberish, amount: BigNumberish];
+    type OutputTuple = [feeType: bigint, amount: bigint];
+    interface OutputObject {
+        feeType: bigint;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace FeeDistributedEvent {
+    type InputTuple = [
+        veRAACAmount: BigNumberish,
+        burnAmount: BigNumberish,
+        repairAmount: BigNumberish,
+        treasuryAmount: BigNumberish
+    ];
+    type OutputTuple = [
+        veRAACAmount: bigint,
+        burnAmount: bigint,
+        repairAmount: bigint,
+        treasuryAmount: bigint
+    ];
+    interface OutputObject {
+        veRAACAmount: bigint;
+        burnAmount: bigint;
+        repairAmount: bigint;
+        treasuryAmount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace FeeTypeUpdatedEvent {
+    type InputTuple = [
+        feeType: BigNumberish,
+        newFee: IFeeCollector.FeeTypeStruct
+    ];
+    type OutputTuple = [
+        feeType: bigint,
+        newFee: IFeeCollector.FeeTypeStructOutput
+    ];
+    interface OutputObject {
+        feeType: bigint;
+        newFee: IFeeCollector.FeeTypeStructOutput;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RepairFundUpdatedEvent {
+    type InputTuple = [newRepairFund: AddressLike];
+    type OutputTuple = [newRepairFund: string];
+    interface OutputObject {
+        newRepairFund: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RewardClaimedEvent {
+    type InputTuple = [user: AddressLike, amount: BigNumberish];
+    type OutputTuple = [user: string, amount: bigint];
+    interface OutputObject {
+        user: string;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TreasuryUpdatedEvent {
+    type InputTuple = [newTreasury: AddressLike];
+    type OutputTuple = [newTreasury: string];
+    interface OutputObject {
+        newTreasury: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IFeeCollector extends BaseContract {
+    connect(runner?: ContractRunner | null): IFeeCollector;
+    waitForDeployment(): Promise<this>;
+    interface: IFeeCollectorInterface;
+    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>;
+    claimRewards: TypedContractMethod<[
+        user: AddressLike
+    ], [
+        bigint
+    ], "nonpayable">;
+    collectFee: TypedContractMethod<[
+        amount: BigNumberish,
+        feeType: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    distributeCollectedFees: TypedContractMethod<[], [void], "nonpayable">;
+    emergencyWithdraw: TypedContractMethod<[
+        token: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getCollectedFees: TypedContractMethod<[
+    ], [
+        IFeeCollector.CollectedFeesStructOutput
+    ], "view">;
+    getFeeType: TypedContractMethod<[
+        feeType: BigNumberish
+    ], [
+        IFeeCollector.FeeTypeStructOutput
+    ], "view">;
+    getPendingRewards: TypedContractMethod<[user: AddressLike], [bigint], "view">;
+    setRepairFund: TypedContractMethod<[
+        newRepairFund: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setTreasury: TypedContractMethod<[
+        newTreasury: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    updateFeeType: TypedContractMethod<[
+        feeType: BigNumberish,
+        newFee: IFeeCollector.FeeTypeStruct
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "claimRewards"): TypedContractMethod<[user: AddressLike], [bigint], "nonpayable">;
+    getFunction(nameOrSignature: "collectFee"): TypedContractMethod<[
+        amount: BigNumberish,
+        feeType: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "distributeCollectedFees"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "emergencyWithdraw"): TypedContractMethod<[token: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "getCollectedFees"): TypedContractMethod<[], [IFeeCollector.CollectedFeesStructOutput], "view">;
+    getFunction(nameOrSignature: "getFeeType"): TypedContractMethod<[
+        feeType: BigNumberish
+    ], [
+        IFeeCollector.FeeTypeStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "getPendingRewards"): TypedContractMethod<[user: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "setRepairFund"): TypedContractMethod<[newRepairFund: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setTreasury"): TypedContractMethod<[newTreasury: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "updateFeeType"): TypedContractMethod<[
+        feeType: BigNumberish,
+        newFee: IFeeCollector.FeeTypeStruct
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "DistributionParametersUpdated"): TypedContractEvent<DistributionParametersUpdatedEvent.InputTuple, DistributionParametersUpdatedEvent.OutputTuple, DistributionParametersUpdatedEvent.OutputObject>;
+    getEvent(key: "EmergencyWithdrawal"): TypedContractEvent<EmergencyWithdrawalEvent.InputTuple, EmergencyWithdrawalEvent.OutputTuple, EmergencyWithdrawalEvent.OutputObject>;
+    getEvent(key: "FeeCollected"): TypedContractEvent<FeeCollectedEvent.InputTuple, FeeCollectedEvent.OutputTuple, FeeCollectedEvent.OutputObject>;
+    getEvent(key: "FeeDistributed"): TypedContractEvent<FeeDistributedEvent.InputTuple, FeeDistributedEvent.OutputTuple, FeeDistributedEvent.OutputObject>;
+    getEvent(key: "FeeTypeUpdated"): TypedContractEvent<FeeTypeUpdatedEvent.InputTuple, FeeTypeUpdatedEvent.OutputTuple, FeeTypeUpdatedEvent.OutputObject>;
+    getEvent(key: "RepairFundUpdated"): TypedContractEvent<RepairFundUpdatedEvent.InputTuple, RepairFundUpdatedEvent.OutputTuple, RepairFundUpdatedEvent.OutputObject>;
+    getEvent(key: "RewardClaimed"): TypedContractEvent<RewardClaimedEvent.InputTuple, RewardClaimedEvent.OutputTuple, RewardClaimedEvent.OutputObject>;
+    getEvent(key: "TreasuryUpdated"): TypedContractEvent<TreasuryUpdatedEvent.InputTuple, TreasuryUpdatedEvent.OutputTuple, TreasuryUpdatedEvent.OutputObject>;
+    filters: {
+        "DistributionParametersUpdated(uint8,tuple)": TypedContractEvent<DistributionParametersUpdatedEvent.InputTuple, DistributionParametersUpdatedEvent.OutputTuple, DistributionParametersUpdatedEvent.OutputObject>;
+        DistributionParametersUpdated: TypedContractEvent<DistributionParametersUpdatedEvent.InputTuple, DistributionParametersUpdatedEvent.OutputTuple, DistributionParametersUpdatedEvent.OutputObject>;
+        "EmergencyWithdrawal(address,uint256)": TypedContractEvent<EmergencyWithdrawalEvent.InputTuple, EmergencyWithdrawalEvent.OutputTuple, EmergencyWithdrawalEvent.OutputObject>;
+        EmergencyWithdrawal: TypedContractEvent<EmergencyWithdrawalEvent.InputTuple, EmergencyWithdrawalEvent.OutputTuple, EmergencyWithdrawalEvent.OutputObject>;
+        "FeeCollected(uint8,uint256)": TypedContractEvent<FeeCollectedEvent.InputTuple, FeeCollectedEvent.OutputTuple, FeeCollectedEvent.OutputObject>;
+        FeeCollected: TypedContractEvent<FeeCollectedEvent.InputTuple, FeeCollectedEvent.OutputTuple, FeeCollectedEvent.OutputObject>;
+        "FeeDistributed(uint256,uint256,uint256,uint256)": TypedContractEvent<FeeDistributedEvent.InputTuple, FeeDistributedEvent.OutputTuple, FeeDistributedEvent.OutputObject>;
+        FeeDistributed: TypedContractEvent<FeeDistributedEvent.InputTuple, FeeDistributedEvent.OutputTuple, FeeDistributedEvent.OutputObject>;
+        "FeeTypeUpdated(uint8,tuple)": TypedContractEvent<FeeTypeUpdatedEvent.InputTuple, FeeTypeUpdatedEvent.OutputTuple, FeeTypeUpdatedEvent.OutputObject>;
+        FeeTypeUpdated: TypedContractEvent<FeeTypeUpdatedEvent.InputTuple, FeeTypeUpdatedEvent.OutputTuple, FeeTypeUpdatedEvent.OutputObject>;
+        "RepairFundUpdated(address)": TypedContractEvent<RepairFundUpdatedEvent.InputTuple, RepairFundUpdatedEvent.OutputTuple, RepairFundUpdatedEvent.OutputObject>;
+        RepairFundUpdated: TypedContractEvent<RepairFundUpdatedEvent.InputTuple, RepairFundUpdatedEvent.OutputTuple, RepairFundUpdatedEvent.OutputObject>;
+        "RewardClaimed(address,uint256)": TypedContractEvent<RewardClaimedEvent.InputTuple, RewardClaimedEvent.OutputTuple, RewardClaimedEvent.OutputObject>;
+        RewardClaimed: TypedContractEvent<RewardClaimedEvent.InputTuple, RewardClaimedEvent.OutputTuple, RewardClaimedEvent.OutputObject>;
+        "TreasuryUpdated(address)": TypedContractEvent<TreasuryUpdatedEvent.InputTuple, TreasuryUpdatedEvent.OutputTuple, TreasuryUpdatedEvent.OutputObject>;
+        TreasuryUpdated: TypedContractEvent<TreasuryUpdatedEvent.InputTuple, TreasuryUpdatedEvent.OutputTuple, TreasuryUpdatedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/contracts/interfaces/core/collectors/ITreasury.d.ts

@@ -0,0 +1,139 @@
+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 ITreasuryInterface extends Interface {
+    getFunction(nameOrSignature: "allocateFunds" | "deposit" | "getAllocation" | "getBalance" | "getTotalValue" | "withdraw"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Deposited" | "FundsAllocated" | "Withdrawn"): EventFragment;
+    encodeFunctionData(functionFragment: "allocateFunds", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "deposit", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getAllocation", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "getBalance", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getTotalValue", values?: undefined): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [AddressLike, BigNumberish, AddressLike]): string;
+    decodeFunctionResult(functionFragment: "allocateFunds", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAllocation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTotalValue", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+}
+export declare namespace DepositedEvent {
+    type InputTuple = [token: AddressLike, amount: BigNumberish];
+    type OutputTuple = [token: string, amount: bigint];
+    interface OutputObject {
+        token: string;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace FundsAllocatedEvent {
+    type InputTuple = [recipient: AddressLike, amount: BigNumberish];
+    type OutputTuple = [recipient: string, amount: bigint];
+    interface OutputObject {
+        recipient: string;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace WithdrawnEvent {
+    type InputTuple = [
+        token: AddressLike,
+        amount: BigNumberish,
+        recipient: AddressLike
+    ];
+    type OutputTuple = [token: string, amount: bigint, recipient: string];
+    interface OutputObject {
+        token: string;
+        amount: bigint;
+        recipient: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ITreasury extends BaseContract {
+    connect(runner?: ContractRunner | null): ITreasury;
+    waitForDeployment(): Promise<this>;
+    interface: ITreasuryInterface;
+    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>;
+    allocateFunds: TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    deposit: TypedContractMethod<[
+        token: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getAllocation: TypedContractMethod<[
+        allocator: AddressLike,
+        recipient: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getBalance: TypedContractMethod<[token: AddressLike], [bigint], "view">;
+    getTotalValue: TypedContractMethod<[], [bigint], "view">;
+    withdraw: TypedContractMethod<[
+        token: AddressLike,
+        amount: BigNumberish,
+        recipient: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allocateFunds"): TypedContractMethod<[
+        recipient: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[
+        token: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "getAllocation"): TypedContractMethod<[
+        allocator: AddressLike,
+        recipient: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "getBalance"): TypedContractMethod<[token: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getTotalValue"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "withdraw"): TypedContractMethod<[
+        token: AddressLike,
+        amount: BigNumberish,
+        recipient: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "Deposited"): TypedContractEvent<DepositedEvent.InputTuple, DepositedEvent.OutputTuple, DepositedEvent.OutputObject>;
+    getEvent(key: "FundsAllocated"): TypedContractEvent<FundsAllocatedEvent.InputTuple, FundsAllocatedEvent.OutputTuple, FundsAllocatedEvent.OutputObject>;
+    getEvent(key: "Withdrawn"): TypedContractEvent<WithdrawnEvent.InputTuple, WithdrawnEvent.OutputTuple, WithdrawnEvent.OutputObject>;
+    filters: {
+        "Deposited(address,uint256)": TypedContractEvent<DepositedEvent.InputTuple, DepositedEvent.OutputTuple, DepositedEvent.OutputObject>;
+        Deposited: TypedContractEvent<DepositedEvent.InputTuple, DepositedEvent.OutputTuple, DepositedEvent.OutputObject>;
+        "FundsAllocated(address,uint256)": TypedContractEvent<FundsAllocatedEvent.InputTuple, FundsAllocatedEvent.OutputTuple, FundsAllocatedEvent.OutputObject>;
+        FundsAllocated: TypedContractEvent<FundsAllocatedEvent.InputTuple, FundsAllocatedEvent.OutputTuple, FundsAllocatedEvent.OutputObject>;
+        "Withdrawn(address,uint256,address)": TypedContractEvent<WithdrawnEvent.InputTuple, WithdrawnEvent.OutputTuple, WithdrawnEvent.OutputObject>;
+        Withdrawn: TypedContractEvent<WithdrawnEvent.InputTuple, WithdrawnEvent.OutputTuple, WithdrawnEvent.OutputObject>;
+    };
+}

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

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