@raac/rpc 1.2.0-beta.4 → 1.2.0-beta.5

package/dist/types/typechain-types/contracts/mocks/core/tokens/MockFeeOnTransferToken.d.ts

@@ -0,0 +1,163 @@
+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 MockFeeOnTransferTokenInterface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "decimals" | "feeBps" | "mint" | "name" | "setFeeBps" | "symbol" | "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: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "feeBps", values?: undefined): string;
+    encodeFunctionData(functionFragment: "mint", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setFeeBps", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): 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: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "feeBps", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setFeeBps", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", 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 MockFeeOnTransferToken extends BaseContract {
+    connect(runner?: ContractRunner | null): MockFeeOnTransferToken;
+    waitForDeployment(): Promise<this>;
+    interface: MockFeeOnTransferTokenInterface;
+    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">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    feeBps: TypedContractMethod<[], [bigint], "view">;
+    mint: TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    setFeeBps: TypedContractMethod<[_feeBps: BigNumberish], [void], "nonpayable">;
+    symbol: TypedContractMethod<[], [string], "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: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "feeBps"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "mint"): TypedContractMethod<[
+        account: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "setFeeBps"): TypedContractMethod<[_feeBps: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "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/dist/types/typechain-types/contracts/mocks/core/tokens/index.d.ts

@@ -2,6 +2,7 @@ export type { ERC20Mock } from "./ERC20Mock";
 export type { ERC721Mock } from "./ERC721Mock";
 export type { MockCollectableUnderlying } from "./MockCollectableUnderlying";
 export type { MockFeeCollectorToken } from "./MockFeeCollectorToken";
+export type { MockFeeOnTransferToken } from "./MockFeeOnTransferToken";
 export type { MockToken } from "./MockToken";
 export type { MockUSDC } from "./MockUSDC";
 export type { RAACMockERC20 } from "./RAACMockERC20";

package/dist/types/typechain-types/contracts/mocks/libraries/index.d.ts

@@ -2,6 +2,8 @@ import type * as governance from "./governance";
 export type { governance };
 import type * as math from "./math";
 export type { math };
+import type * as minters from "./minters";
+export type { minters };
 import type * as pools from "./pools";
 export type { pools };
 export type { MockStringUtils } from "./MockStringUtils";

package/dist/types/typechain-types/contracts/mocks/libraries/minters/EmissionScheduleMock.d.ts

@@ -0,0 +1,91 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export declare namespace EmissionSchedule {
+    type WeeklyEmissionStruct = {
+        weekNumber: BigNumberish;
+        secondsInWeek: BigNumberish;
+        emissionsInWeek: BigNumberish;
+    };
+    type WeeklyEmissionStructOutput = [
+        weekNumber: bigint,
+        secondsInWeek: bigint,
+        emissionsInWeek: bigint
+    ] & {
+        weekNumber: bigint;
+        secondsInWeek: bigint;
+        emissionsInWeek: bigint;
+    };
+}
+export interface EmissionScheduleMockInterface extends Interface {
+    getFunction(nameOrSignature: "calculateScheduledMintableAmount" | "computeWeeklyEmissions" | "getEmissionPerSecondForWeek" | "getMintingWeekForTimestamp"): FunctionFragment;
+    encodeFunctionData(functionFragment: "calculateScheduledMintableAmount", values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "computeWeeklyEmissions", values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getEmissionPerSecondForWeek", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getMintingWeekForTimestamp", values: [BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "calculateScheduledMintableAmount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "computeWeeklyEmissions", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getEmissionPerSecondForWeek", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getMintingWeekForTimestamp", data: BytesLike): Result;
+}
+export interface EmissionScheduleMock extends BaseContract {
+    connect(runner?: ContractRunner | null): EmissionScheduleMock;
+    waitForDeployment(): Promise<this>;
+    interface: EmissionScheduleMockInterface;
+    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>;
+    calculateScheduledMintableAmount: TypedContractMethod<[
+        activationTimestamp: BigNumberish,
+        startTime: BigNumberish,
+        endTime: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    computeWeeklyEmissions: TypedContractMethod<[
+        activationTimestamp: BigNumberish,
+        startTime: BigNumberish,
+        endTime: BigNumberish
+    ], [
+        EmissionSchedule.WeeklyEmissionStructOutput[]
+    ], "view">;
+    getEmissionPerSecondForWeek: TypedContractMethod<[
+        weekNumber: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getMintingWeekForTimestamp: TypedContractMethod<[
+        activationTimestamp: BigNumberish,
+        timestamp: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "calculateScheduledMintableAmount"): TypedContractMethod<[
+        activationTimestamp: BigNumberish,
+        startTime: BigNumberish,
+        endTime: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "computeWeeklyEmissions"): TypedContractMethod<[
+        activationTimestamp: BigNumberish,
+        startTime: BigNumberish,
+        endTime: BigNumberish
+    ], [
+        EmissionSchedule.WeeklyEmissionStructOutput[]
+    ], "view">;
+    getFunction(nameOrSignature: "getEmissionPerSecondForWeek"): TypedContractMethod<[weekNumber: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "getMintingWeekForTimestamp"): TypedContractMethod<[
+        activationTimestamp: BigNumberish,
+        timestamp: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    filters: {};
+}

package/dist/types/typechain-types/contracts/mocks/libraries/minters/index.d.ts

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

package/dist/types/typechain-types/contracts/rwaf/ChainlinkOracleAdapter.sol/ChainlinkOracleAdapter.d.ts

@@ -0,0 +1,212 @@
+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 ChainlinkOracleAdapterInterface extends Interface {
+    getFunction(nameOrSignature: "BPS_PRECISION" | "DECIMALS" | "emergencyPrice" | "getPrice" | "getSharePrice" | "maxStaleTime" | "owner" | "priceFeed" | "priceTolerance" | "renounceOwnership" | "setEmergencyPrice" | "setMaxStaleTime" | "setPriceFeed" | "setPriceTolerance" | "transferOwnership"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "EmergencyPriceUpdated" | "MaxStaleTimeUpdated" | "OwnershipTransferred" | "PriceFeedUpdated" | "PriceToleranceUpdated"): EventFragment;
+    encodeFunctionData(functionFragment: "BPS_PRECISION", values?: undefined): string;
+    encodeFunctionData(functionFragment: "DECIMALS", values?: undefined): string;
+    encodeFunctionData(functionFragment: "emergencyPrice", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getPrice", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getSharePrice", values?: undefined): string;
+    encodeFunctionData(functionFragment: "maxStaleTime", values?: undefined): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "priceFeed", values?: undefined): string;
+    encodeFunctionData(functionFragment: "priceTolerance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setEmergencyPrice", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setMaxStaleTime", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setPriceFeed", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setPriceTolerance", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "BPS_PRECISION", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "DECIMALS", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "emergencyPrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getSharePrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "maxStaleTime", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "priceFeed", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "priceTolerance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setEmergencyPrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setMaxStaleTime", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setPriceFeed", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setPriceTolerance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+}
+export declare namespace EmergencyPriceUpdatedEvent {
+    type InputTuple = [newEmergencyPrice: BigNumberish];
+    type OutputTuple = [newEmergencyPrice: bigint];
+    interface OutputObject {
+        newEmergencyPrice: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace MaxStaleTimeUpdatedEvent {
+    type InputTuple = [newMaxStaleTime: BigNumberish];
+    type OutputTuple = [newMaxStaleTime: bigint];
+    interface OutputObject {
+        newMaxStaleTime: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace OwnershipTransferredEvent {
+    type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike];
+    type OutputTuple = [previousOwner: string, newOwner: string];
+    interface OutputObject {
+        previousOwner: string;
+        newOwner: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace PriceFeedUpdatedEvent {
+    type InputTuple = [newPriceFeed: AddressLike];
+    type OutputTuple = [newPriceFeed: string];
+    interface OutputObject {
+        newPriceFeed: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace PriceToleranceUpdatedEvent {
+    type InputTuple = [newPriceTolerance: BigNumberish];
+    type OutputTuple = [newPriceTolerance: bigint];
+    interface OutputObject {
+        newPriceTolerance: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ChainlinkOracleAdapter extends BaseContract {
+    connect(runner?: ContractRunner | null): ChainlinkOracleAdapter;
+    waitForDeployment(): Promise<this>;
+    interface: ChainlinkOracleAdapterInterface;
+    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>;
+    BPS_PRECISION: TypedContractMethod<[], [bigint], "view">;
+    DECIMALS: TypedContractMethod<[], [bigint], "view">;
+    emergencyPrice: TypedContractMethod<[], [bigint], "view">;
+    getPrice: TypedContractMethod<[
+    ], [
+        [
+            boolean,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            isValid: boolean;
+            price: bigint;
+            minUnsafePrice: bigint;
+            maxUnsafePrice: bigint;
+        }
+    ], "view">;
+    getSharePrice: TypedContractMethod<[
+    ], [
+        [boolean, bigint] & {
+            isValid: boolean;
+            sharePrice: bigint;
+        }
+    ], "view">;
+    maxStaleTime: TypedContractMethod<[], [bigint], "view">;
+    owner: TypedContractMethod<[], [string], "view">;
+    priceFeed: TypedContractMethod<[], [string], "view">;
+    priceTolerance: TypedContractMethod<[], [bigint], "view">;
+    renounceOwnership: TypedContractMethod<[], [void], "nonpayable">;
+    setEmergencyPrice: TypedContractMethod<[
+        _emergencyPrice: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setMaxStaleTime: TypedContractMethod<[
+        _maxStaleTime: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setPriceFeed: TypedContractMethod<[
+        _priceFeed: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setPriceTolerance: TypedContractMethod<[
+        _priceTolerance: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    transferOwnership: TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "BPS_PRECISION"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "DECIMALS"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "emergencyPrice"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "getPrice"): TypedContractMethod<[
+    ], [
+        [
+            boolean,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            isValid: boolean;
+            price: bigint;
+            minUnsafePrice: bigint;
+            maxUnsafePrice: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "getSharePrice"): TypedContractMethod<[
+    ], [
+        [boolean, bigint] & {
+            isValid: boolean;
+            sharePrice: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "maxStaleTime"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "owner"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "priceFeed"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "priceTolerance"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "renounceOwnership"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setEmergencyPrice"): TypedContractMethod<[_emergencyPrice: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setMaxStaleTime"): TypedContractMethod<[_maxStaleTime: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setPriceFeed"): TypedContractMethod<[_priceFeed: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setPriceTolerance"): TypedContractMethod<[_priceTolerance: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "transferOwnership"): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+    getEvent(key: "EmergencyPriceUpdated"): TypedContractEvent<EmergencyPriceUpdatedEvent.InputTuple, EmergencyPriceUpdatedEvent.OutputTuple, EmergencyPriceUpdatedEvent.OutputObject>;
+    getEvent(key: "MaxStaleTimeUpdated"): TypedContractEvent<MaxStaleTimeUpdatedEvent.InputTuple, MaxStaleTimeUpdatedEvent.OutputTuple, MaxStaleTimeUpdatedEvent.OutputObject>;
+    getEvent(key: "OwnershipTransferred"): TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+    getEvent(key: "PriceFeedUpdated"): TypedContractEvent<PriceFeedUpdatedEvent.InputTuple, PriceFeedUpdatedEvent.OutputTuple, PriceFeedUpdatedEvent.OutputObject>;
+    getEvent(key: "PriceToleranceUpdated"): TypedContractEvent<PriceToleranceUpdatedEvent.InputTuple, PriceToleranceUpdatedEvent.OutputTuple, PriceToleranceUpdatedEvent.OutputObject>;
+    filters: {
+        "EmergencyPriceUpdated(uint256)": TypedContractEvent<EmergencyPriceUpdatedEvent.InputTuple, EmergencyPriceUpdatedEvent.OutputTuple, EmergencyPriceUpdatedEvent.OutputObject>;
+        EmergencyPriceUpdated: TypedContractEvent<EmergencyPriceUpdatedEvent.InputTuple, EmergencyPriceUpdatedEvent.OutputTuple, EmergencyPriceUpdatedEvent.OutputObject>;
+        "MaxStaleTimeUpdated(uint256)": TypedContractEvent<MaxStaleTimeUpdatedEvent.InputTuple, MaxStaleTimeUpdatedEvent.OutputTuple, MaxStaleTimeUpdatedEvent.OutputObject>;
+        MaxStaleTimeUpdated: TypedContractEvent<MaxStaleTimeUpdatedEvent.InputTuple, MaxStaleTimeUpdatedEvent.OutputTuple, MaxStaleTimeUpdatedEvent.OutputObject>;
+        "OwnershipTransferred(address,address)": TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        OwnershipTransferred: TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        "PriceFeedUpdated(address)": TypedContractEvent<PriceFeedUpdatedEvent.InputTuple, PriceFeedUpdatedEvent.OutputTuple, PriceFeedUpdatedEvent.OutputObject>;
+        PriceFeedUpdated: TypedContractEvent<PriceFeedUpdatedEvent.InputTuple, PriceFeedUpdatedEvent.OutputTuple, PriceFeedUpdatedEvent.OutputObject>;
+        "PriceToleranceUpdated(uint256)": TypedContractEvent<PriceToleranceUpdatedEvent.InputTuple, PriceToleranceUpdatedEvent.OutputTuple, PriceToleranceUpdatedEvent.OutputObject>;
+        PriceToleranceUpdated: TypedContractEvent<PriceToleranceUpdatedEvent.InputTuple, PriceToleranceUpdatedEvent.OutputTuple, PriceToleranceUpdatedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/contracts/rwaf/ChainlinkOracleAdapter.sol/IRWACoordinator.d.ts

@@ -0,0 +1,67 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface IRWACoordinatorInterface extends Interface {
+    getFunction(nameOrSignature: "getPrice" | "getSharePrice"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getPrice", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getSharePrice", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "getPrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getSharePrice", data: BytesLike): Result;
+}
+export interface IRWACoordinator extends BaseContract {
+    connect(runner?: ContractRunner | null): IRWACoordinator;
+    waitForDeployment(): Promise<this>;
+    interface: IRWACoordinatorInterface;
+    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>;
+    getPrice: TypedContractMethod<[
+    ], [
+        [
+            boolean,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            isValid: boolean;
+            price: bigint;
+            minUnsafePrice: bigint;
+            maxUnsafePrice: bigint;
+        }
+    ], "view">;
+    getSharePrice: TypedContractMethod<[
+    ], [
+        [boolean, bigint] & {
+            isValid: boolean;
+            sharePrice: bigint;
+        }
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "getPrice"): TypedContractMethod<[
+    ], [
+        [
+            boolean,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            isValid: boolean;
+            price: bigint;
+            minUnsafePrice: bigint;
+            maxUnsafePrice: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "getSharePrice"): TypedContractMethod<[
+    ], [
+        [boolean, bigint] & {
+            isValid: boolean;
+            sharePrice: bigint;
+        }
+    ], "view">;
+    filters: {};
+}

package/dist/types/typechain-types/contracts/rwaf/ChainlinkOracleAdapter.sol/index.d.ts

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