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

package/dist/types/typechain-types/psm/imports.sol/PSMProxyAdmin.d.ts

@@ -0,0 +1,96 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../common.js";
+export interface PSMProxyAdminInterface extends Interface {
+    getFunction(nameOrSignature: "UPGRADE_INTERFACE_VERSION" | "owner" | "renounceOwnership" | "transferOwnership" | "upgradeAndCall"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+    encodeFunctionData(functionFragment: 'UPGRADE_INTERFACE_VERSION', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'owner', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'transferOwnership', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'upgradeAndCall', values: [AddressLike, AddressLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: 'UPGRADE_INTERFACE_VERSION', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'upgradeAndCall', data: BytesLike): Result;
+}
+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 interface PSMProxyAdmin extends BaseContract {
+    connect(runner?: ContractRunner | null): PSMProxyAdmin;
+    waitForDeployment(): Promise<this>;
+    interface: PSMProxyAdminInterface;
+    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>;
+    UPGRADE_INTERFACE_VERSION: TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    owner: TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    renounceOwnership: TypedContractMethod<[
+    ], [
+        void
+    ], 'nonpayable'>;
+    transferOwnership: TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], 'nonpayable'>;
+    upgradeAndCall: TypedContractMethod<[
+        proxy: AddressLike,
+        implementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], 'payable'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'UPGRADE_INTERFACE_VERSION'): TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    getFunction(nameOrSignature: 'owner'): TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    getFunction(nameOrSignature: 'renounceOwnership'): TypedContractMethod<[
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'transferOwnership'): TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'upgradeAndCall'): TypedContractMethod<[
+        proxy: AddressLike,
+        implementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], 'payable'>;
+    getEvent(key: 'OwnershipTransferred'): TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+    filters: {
+        'OwnershipTransferred(address,address)': TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        OwnershipTransferred: TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/psm/imports.sol/PSMTransparentProxy.d.ts

@@ -0,0 +1,51 @@
+import type { BaseContract, FunctionFragment, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener } from "../common.js";
+export interface PSMTransparentProxyInterface extends Interface {
+    getEvent(nameOrSignatureOrTopic: "AdminChanged" | "Upgraded"): EventFragment;
+}
+export declare namespace AdminChangedEvent {
+    type InputTuple = [previousAdmin: AddressLike, newAdmin: AddressLike];
+    type OutputTuple = [previousAdmin: string, newAdmin: string];
+    interface OutputObject {
+        previousAdmin: string;
+        newAdmin: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UpgradedEvent {
+    type InputTuple = [implementation: AddressLike];
+    type OutputTuple = [implementation: string];
+    interface OutputObject {
+        implementation: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface PSMTransparentProxy extends BaseContract {
+    connect(runner?: ContractRunner | null): PSMTransparentProxy;
+    waitForDeployment(): Promise<this>;
+    interface: PSMTransparentProxyInterface;
+    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>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getEvent(key: 'AdminChanged'): TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+    getEvent(key: 'Upgraded'): TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    filters: {
+        'AdminChanged(address,address)': TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        AdminChanged: TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        'Upgraded(address)': TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+        Upgraded: TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/psm/imports.sol/index.d.ts

@@ -0,0 +1,2 @@
+export type { PSMProxyAdmin } from './PSMProxyAdmin.js';
+export type { PSMTransparentProxy } from './PSMTransparentProxy.js';

package/dist/types/typechain-types/psm/index.d.ts

@@ -0,0 +1,157 @@
+import type * as importsSol from './imports.sol/index.js';
+export type { importsSol };
+import type * as interfaces from './interfaces/index.js';
+export type { interfaces };
+import type * as mocks from './mocks/index.js';
+export type { mocks };
+import type * as utils from './utils/index.js';
+export type { utils };
+import type * as v2 from './v2/index.js';
+export type { v2 };
+import type * as v3 from './v3/index.js';
+export type { v3 };
+export type { PSMVault } from './PSMVault.js';
+export type { RateProvider } from './RateProvider.js';
+export * as factories from './factories/index.js';
+export { PSMVault__factory } from './factories/PSMVault__factory.js';
+export { RateProvider__factory } from './factories/RateProvider__factory.js';
+export type { PSMProxyAdmin } from './imports.sol/PSMProxyAdmin.js';
+export { PSMProxyAdmin__factory } from './factories/imports.sol/PSMProxyAdmin__factory.js';
+export type { PSMTransparentProxy } from './imports.sol/PSMTransparentProxy.js';
+export { PSMTransparentProxy__factory } from './factories/imports.sol/PSMTransparentProxy__factory.js';
+export type { IBaseAssetNav } from './interfaces/IBaseAssetNav.js';
+export { IBaseAssetNav__factory } from './factories/interfaces/IBaseAssetNav__factory.js';
+export type { IRateProvider } from './interfaces/IRateProvider.js';
+export { IRateProvider__factory } from './factories/interfaces/IRateProvider__factory.js';
+export type { IRebalancer } from './interfaces/IRebalancer.js';
+export { IRebalancer__factory } from './factories/interfaces/IRebalancer__factory.js';
+export type { ISavingsToken } from './interfaces/ISavingsToken.js';
+export { ISavingsToken__factory } from './factories/interfaces/ISavingsToken__factory.js';
+export type { IRebalancerV2 } from './interfaces/v2/IRebalancerV2.js';
+export { IRebalancerV2__factory } from './factories/interfaces/v2/IRebalancerV2__factory.js';
+export type { IRateProviderV3 } from './interfaces/v3/IRateProviderV3.js';
+export { IRateProviderV3__factory } from './factories/interfaces/v3/IRateProviderV3__factory.js';
+export type { MockBaseAssetModule } from './mocks/MockBaseAssetModule.js';
+export { MockBaseAssetModule__factory } from './factories/mocks/MockBaseAssetModule__factory.js';
+export type { MockChainlinkFeed } from './mocks/MockChainlinkFeed.js';
+export { MockChainlinkFeed__factory } from './factories/mocks/MockChainlinkFeed__factory.js';
+export type { MockERC20 } from './mocks/MockERC20.js';
+export { MockERC20__factory } from './factories/mocks/MockERC20__factory.js';
+export type { MockFeeOnTransferERC20 } from './mocks/MockFeeOnTransferERC20.js';
+export { MockFeeOnTransferERC20__factory } from './factories/mocks/MockFeeOnTransferERC20__factory.js';
+export type { MockPmUSD } from './mocks/MockPmUSD.js';
+export { MockPmUSD__factory } from './factories/mocks/MockPmUSD__factory.js';
+export type { MockProxy } from './mocks/MockProxy.js';
+export { MockProxy__factory } from './factories/mocks/MockProxy__factory.js';
+export type { IMockMintable } from './mocks/MockRebalancer.sol/IMockMintable.js';
+export { IMockMintable__factory } from './factories/mocks/MockRebalancer.sol/IMockMintable__factory.js';
+export type { MockRebalancer } from './mocks/MockRebalancer.sol/MockRebalancer.js';
+export { MockRebalancer__factory } from './factories/mocks/MockRebalancer.sol/MockRebalancer__factory.js';
+export type { MockRebalancerV2 } from './mocks/MockRebalancerV2.sol/MockRebalancerV2.js';
+export { MockRebalancerV2__factory } from './factories/mocks/MockRebalancerV2.sol/MockRebalancerV2__factory.js';
+export type { MockSavingsToken } from './mocks/MockSavingsToken.js';
+export { MockSavingsToken__factory } from './factories/mocks/MockSavingsToken__factory.js';
+export type { AladdinZap } from './utils/zap/AladdinZap.js';
+export { AladdinZap__factory } from './factories/utils/zap/AladdinZap__factory.js';
+export type { TokenZapLogic } from './utils/zap/TokenZapLogic.js';
+export { TokenZapLogic__factory } from './factories/utils/zap/TokenZapLogic__factory.js';
+export type { IBalancerPool } from './utils/zap/interfaces/IBalancerPool.js';
+export { IBalancerPool__factory } from './factories/utils/zap/interfaces/IBalancerPool__factory.js';
+export type { IBalancerVault } from './utils/zap/interfaces/IBalancerVault.js';
+export { IBalancerVault__factory } from './factories/utils/zap/interfaces/IBalancerVault__factory.js';
+export type { IConvexCRVDepositor } from './utils/zap/interfaces/IConvexCRVDepositor.js';
+export { IConvexCRVDepositor__factory } from './factories/utils/zap/interfaces/IConvexCRVDepositor__factory.js';
+export type { ICurveA2Pool } from './utils/zap/interfaces/ICurveAPool.sol/ICurveA2Pool.js';
+export { ICurveA2Pool__factory } from './factories/utils/zap/interfaces/ICurveAPool.sol/ICurveA2Pool__factory.js';
+export type { ICurveA3Pool } from './utils/zap/interfaces/ICurveAPool.sol/ICurveA3Pool.js';
+export { ICurveA3Pool__factory } from './factories/utils/zap/interfaces/ICurveAPool.sol/ICurveA3Pool__factory.js';
+export type { ICurveA4Pool } from './utils/zap/interfaces/ICurveAPool.sol/ICurveA4Pool.js';
+export { ICurveA4Pool__factory } from './factories/utils/zap/interfaces/ICurveAPool.sol/ICurveA4Pool__factory.js';
+export type { ICurveAPool } from './utils/zap/interfaces/ICurveAPool.sol/ICurveAPool.js';
+export { ICurveAPool__factory } from './factories/utils/zap/interfaces/ICurveAPool.sol/ICurveAPool__factory.js';
+export type { ICurveBase2Pool } from './utils/zap/interfaces/ICurveBasePool.sol/ICurveBase2Pool.js';
+export { ICurveBase2Pool__factory } from './factories/utils/zap/interfaces/ICurveBasePool.sol/ICurveBase2Pool__factory.js';
+export type { ICurveBase3Pool } from './utils/zap/interfaces/ICurveBasePool.sol/ICurveBase3Pool.js';
+export { ICurveBase3Pool__factory } from './factories/utils/zap/interfaces/ICurveBasePool.sol/ICurveBase3Pool__factory.js';
+export type { ICurveBase4Pool } from './utils/zap/interfaces/ICurveBasePool.sol/ICurveBase4Pool.js';
+export { ICurveBase4Pool__factory } from './factories/utils/zap/interfaces/ICurveBasePool.sol/ICurveBase4Pool__factory.js';
+export type { ICurveBasePool } from './utils/zap/interfaces/ICurveBasePool.sol/ICurveBasePool.js';
+export { ICurveBasePool__factory } from './factories/utils/zap/interfaces/ICurveBasePool.sol/ICurveBasePool__factory.js';
+export type { ICurveCryptoPool } from './utils/zap/interfaces/ICurveCryptoPool.sol/ICurveCryptoPool.js';
+export { ICurveCryptoPool__factory } from './factories/utils/zap/interfaces/ICurveCryptoPool.sol/ICurveCryptoPool__factory.js';
+export type { ICurveTriCryptoPool } from './utils/zap/interfaces/ICurveCryptoPool.sol/ICurveTriCryptoPool.js';
+export { ICurveTriCryptoPool__factory } from './factories/utils/zap/interfaces/ICurveCryptoPool.sol/ICurveTriCryptoPool__factory.js';
+export type { IZapCurveMetaCryptoPool } from './utils/zap/interfaces/ICurveCryptoPool.sol/IZapCurveMetaCryptoPool.js';
+export { IZapCurveMetaCryptoPool__factory } from './factories/utils/zap/interfaces/ICurveCryptoPool.sol/IZapCurveMetaCryptoPool__factory.js';
+export type { ICurveETHPool } from './utils/zap/interfaces/ICurveETHPool.js';
+export { ICurveETHPool__factory } from './factories/utils/zap/interfaces/ICurveETHPool__factory.js';
+export type { ICurveDepositZap } from './utils/zap/interfaces/ICurveFactoryMetaPool.sol/ICurveDepositZap.js';
+export { ICurveDepositZap__factory } from './factories/utils/zap/interfaces/ICurveFactoryMetaPool.sol/ICurveDepositZap__factory.js';
+export type { ICurveDepositZap3Pool } from './utils/zap/interfaces/ICurveFactoryMetaPool.sol/ICurveDepositZap3Pool.js';
+export { ICurveDepositZap3Pool__factory } from './factories/utils/zap/interfaces/ICurveFactoryMetaPool.sol/ICurveDepositZap3Pool__factory.js';
+export type { ICurveDepositZap4Pool } from './utils/zap/interfaces/ICurveFactoryMetaPool.sol/ICurveDepositZap4Pool.js';
+export { ICurveDepositZap4Pool__factory } from './factories/utils/zap/interfaces/ICurveFactoryMetaPool.sol/ICurveDepositZap4Pool__factory.js';
+export type { ICurveFactoryMetaPool } from './utils/zap/interfaces/ICurveFactoryMetaPool.sol/ICurveFactoryMetaPool.js';
+export { ICurveFactoryMetaPool__factory } from './factories/utils/zap/interfaces/ICurveFactoryMetaPool.sol/ICurveFactoryMetaPool__factory.js';
+export type { ICurveFactoryPlain2Pool } from './utils/zap/interfaces/ICurveFactoryPlainPool.sol/ICurveFactoryPlain2Pool.js';
+export { ICurveFactoryPlain2Pool__factory } from './factories/utils/zap/interfaces/ICurveFactoryPlainPool.sol/ICurveFactoryPlain2Pool__factory.js';
+export type { ICurveFactoryPlain3Pool } from './utils/zap/interfaces/ICurveFactoryPlainPool.sol/ICurveFactoryPlain3Pool.js';
+export { ICurveFactoryPlain3Pool__factory } from './factories/utils/zap/interfaces/ICurveFactoryPlainPool.sol/ICurveFactoryPlain3Pool__factory.js';
+export type { ICurveFactoryPlain4Pool } from './utils/zap/interfaces/ICurveFactoryPlainPool.sol/ICurveFactoryPlain4Pool.js';
+export { ICurveFactoryPlain4Pool__factory } from './factories/utils/zap/interfaces/ICurveFactoryPlainPool.sol/ICurveFactoryPlain4Pool__factory.js';
+export type { ICurveFactoryPlainPool } from './utils/zap/interfaces/ICurveFactoryPlainPool.sol/ICurveFactoryPlainPool.js';
+export { ICurveFactoryPlainPool__factory } from './factories/utils/zap/interfaces/ICurveFactoryPlainPool.sol/ICurveFactoryPlainPool__factory.js';
+export type { ICurveMetaPoolDeposit } from './utils/zap/interfaces/ICurveMetaPool.sol/ICurveMetaPoolDeposit.js';
+export { ICurveMetaPoolDeposit__factory } from './factories/utils/zap/interfaces/ICurveMetaPool.sol/ICurveMetaPoolDeposit__factory.js';
+export type { ICurveMetaPoolSwap } from './utils/zap/interfaces/ICurveMetaPool.sol/ICurveMetaPoolSwap.js';
+export { ICurveMetaPoolSwap__factory } from './factories/utils/zap/interfaces/ICurveMetaPool.sol/ICurveMetaPoolSwap__factory.js';
+export type { ICurvePoolRegistry } from './utils/zap/interfaces/ICurvePoolRegistry.js';
+export { ICurvePoolRegistry__factory } from './factories/utils/zap/interfaces/ICurvePoolRegistry__factory.js';
+export type { ICurveY2PoolDeposit } from './utils/zap/interfaces/ICurveYPool.sol/ICurveY2PoolDeposit.js';
+export { ICurveY2PoolDeposit__factory } from './factories/utils/zap/interfaces/ICurveYPool.sol/ICurveY2PoolDeposit__factory.js';
+export type { ICurveY2PoolSwap } from './utils/zap/interfaces/ICurveYPool.sol/ICurveY2PoolSwap.js';
+export { ICurveY2PoolSwap__factory } from './factories/utils/zap/interfaces/ICurveYPool.sol/ICurveY2PoolSwap__factory.js';
+export type { ICurveY3PoolDeposit } from './utils/zap/interfaces/ICurveYPool.sol/ICurveY3PoolDeposit.js';
+export { ICurveY3PoolDeposit__factory } from './factories/utils/zap/interfaces/ICurveYPool.sol/ICurveY3PoolDeposit__factory.js';
+export type { ICurveY3PoolSwap } from './utils/zap/interfaces/ICurveYPool.sol/ICurveY3PoolSwap.js';
+export { ICurveY3PoolSwap__factory } from './factories/utils/zap/interfaces/ICurveYPool.sol/ICurveY3PoolSwap__factory.js';
+export type { ICurveY4PoolDeposit } from './utils/zap/interfaces/ICurveYPool.sol/ICurveY4PoolDeposit.js';
+export { ICurveY4PoolDeposit__factory } from './factories/utils/zap/interfaces/ICurveYPool.sol/ICurveY4PoolDeposit__factory.js';
+export type { ICurveY4PoolSwap } from './utils/zap/interfaces/ICurveYPool.sol/ICurveY4PoolSwap.js';
+export { ICurveY4PoolSwap__factory } from './factories/utils/zap/interfaces/ICurveYPool.sol/ICurveY4PoolSwap__factory.js';
+export type { ICurveYPoolDeposit } from './utils/zap/interfaces/ICurveYPool.sol/ICurveYPoolDeposit.js';
+export { ICurveYPoolDeposit__factory } from './factories/utils/zap/interfaces/ICurveYPool.sol/ICurveYPoolDeposit__factory.js';
+export type { ICurveYPoolSwap } from './utils/zap/interfaces/ICurveYPool.sol/ICurveYPoolSwap.js';
+export { ICurveYPoolSwap__factory } from './factories/utils/zap/interfaces/ICurveYPool.sol/ICurveYPoolSwap__factory.js';
+export type { ILidoStETH } from './utils/zap/interfaces/ILidoStETH.js';
+export { ILidoStETH__factory } from './factories/utils/zap/interfaces/ILidoStETH__factory.js';
+export type { ILidoWstETH } from './utils/zap/interfaces/ILidoWstETH.js';
+export { ILidoWstETH__factory } from './factories/utils/zap/interfaces/ILidoWstETH__factory.js';
+export type { IUniswapV2Pair } from './utils/zap/interfaces/IUniswapV2Pair.js';
+export { IUniswapV2Pair__factory } from './factories/utils/zap/interfaces/IUniswapV2Pair__factory.js';
+export type { IUniswapV3Pool } from './utils/zap/interfaces/IUniswapV3Pool.js';
+export { IUniswapV3Pool__factory } from './factories/utils/zap/interfaces/IUniswapV3Pool__factory.js';
+export type { IUniswapV3Router } from './utils/zap/interfaces/IUniswapV3Router.js';
+export { IUniswapV3Router__factory } from './factories/utils/zap/interfaces/IUniswapV3Router__factory.js';
+export type { IWETH } from './utils/zap/interfaces/IWETH.js';
+export { IWETH__factory } from './factories/utils/zap/interfaces/IWETH__factory.js';
+export type { IZap } from './utils/zap/interfaces/IZap.js';
+export { IZap__factory } from './factories/utils/zap/interfaces/IZap__factory.js';
+export type { IAladdinCRV } from './utils/zap/interfaces/concentrator/IAladdinCRV.js';
+export { IAladdinCRV__factory } from './factories/utils/zap/interfaces/concentrator/IAladdinCRV__factory.js';
+export type { IAladdinCompounder } from './utils/zap/interfaces/concentrator/IAladdinCompounder.js';
+export { IAladdinCompounder__factory } from './factories/utils/zap/interfaces/concentrator/IAladdinCompounder__factory.js';
+export type { PSMVaultV2 } from './v2/PSMVaultV2.js';
+export { PSMVaultV2__factory } from './factories/v2/PSMVaultV2__factory.js';
+export type { IPSMVaultView } from './v2/RebalancerV2.sol/IPSMVaultView.js';
+export { IPSMVaultView__factory } from './factories/v2/RebalancerV2.sol/IPSMVaultView__factory.js';
+export type { IRateOracle } from './v2/RebalancerV2.sol/IRateOracle.js';
+export { IRateOracle__factory } from './factories/v2/RebalancerV2.sol/IRateOracle__factory.js';
+export type { RebalancerV2 } from './v2/RebalancerV2.sol/RebalancerV2.js';
+export { RebalancerV2__factory } from './factories/v2/RebalancerV2.sol/RebalancerV2__factory.js';
+export type { PSMVaultV3 } from './v3/PSMVaultV3.js';
+export { PSMVaultV3__factory } from './factories/v3/PSMVaultV3__factory.js';
+export type { RateProviderComposed } from './v3/RateProviderComposed.js';
+export { RateProviderComposed__factory } from './factories/v3/RateProviderComposed__factory.js';
+export type { RateProviderDirect } from './v3/RateProviderDirect.js';
+export { RateProviderDirect__factory } from './factories/v3/RateProviderDirect__factory.js';

package/dist/types/typechain-types/psm/interfaces/IBaseAssetNav.d.ts

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

package/dist/types/typechain-types/psm/interfaces/IRateProvider.d.ts

@@ -0,0 +1,75 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../common.js";
+export interface IRateProviderInterface extends Interface {
+    getFunction(nameOrSignature: "baseAsset" | "getRate" | "getRateRoundUp" | "getUnderlyingPrice" | "savingsToken"): FunctionFragment;
+    encodeFunctionData(functionFragment: 'baseAsset', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'getRate', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'getRateRoundUp', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'getUnderlyingPrice', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'savingsToken', values?: undefined): string;
+    decodeFunctionResult(functionFragment: 'baseAsset', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getRate', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getRateRoundUp', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getUnderlyingPrice', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'savingsToken', data: BytesLike): Result;
+}
+export interface IRateProvider extends BaseContract {
+    connect(runner?: ContractRunner | null): IRateProvider;
+    waitForDeployment(): Promise<this>;
+    interface: IRateProviderInterface;
+    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>;
+    baseAsset: TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    getRate: TypedContractMethod<[
+        token: AddressLike
+    ], [
+        bigint
+    ], 'view'>;
+    getRateRoundUp: TypedContractMethod<[
+        token: AddressLike
+    ], [
+        bigint
+    ], 'view'>;
+    getUnderlyingPrice: TypedContractMethod<[
+    ], [
+        bigint
+    ], 'view'>;
+    savingsToken: TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'baseAsset'): TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    getFunction(nameOrSignature: 'getRate'): TypedContractMethod<[
+        token: AddressLike
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'getRateRoundUp'): TypedContractMethod<[
+        token: AddressLike
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'getUnderlyingPrice'): TypedContractMethod<[
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'savingsToken'): TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    filters: {};
+}

package/dist/types/typechain-types/psm/interfaces/IRebalancer.d.ts

@@ -0,0 +1,39 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../common.js";
+export interface IRebalancerInterface extends Interface {
+    getFunction(nameOrSignature: "rebalance"): FunctionFragment;
+    encodeFunctionData(functionFragment: 'rebalance', values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: 'rebalance', data: BytesLike): Result;
+}
+export interface IRebalancer extends BaseContract {
+    connect(runner?: ContractRunner | null): IRebalancer;
+    waitForDeployment(): Promise<this>;
+    interface: IRebalancerInterface;
+    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>;
+    rebalance: TypedContractMethod<[
+        pmUSDAmount: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            savingsTokenReceived: bigint;
+            pmUSDRemaining: bigint;
+        }
+    ], 'nonpayable'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'rebalance'): TypedContractMethod<[
+        pmUSDAmount: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            savingsTokenReceived: bigint;
+            pmUSDRemaining: bigint;
+        }
+    ], 'nonpayable'>;
+    filters: {};
+}