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

package/dist/types/typechain-types/psm/utils/zap/interfaces/ICurveYPool.sol/ICurveYPoolSwap.d.ts

@@ -0,0 +1,179 @@
+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 ICurveYPoolSwapInterface extends Interface {
+    getFunction(nameOrSignature: "add_liquidity(uint256[4],uint256)" | "add_liquidity(uint256[2],uint256)" | "add_liquidity(uint256[3],uint256)" | "coins(int128)" | "coins(uint256)" | "exchange" | "exchange_underlying" | "get_dy" | "get_dy_underlying" | "underlying_coins(int128)" | "underlying_coins(uint256)"): FunctionFragment;
+    encodeFunctionData(functionFragment: 'add_liquidity(uint256[4],uint256)', values: [[BigNumberish, BigNumberish, BigNumberish, BigNumberish], BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'add_liquidity(uint256[2],uint256)', values: [[BigNumberish, BigNumberish], BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'add_liquidity(uint256[3],uint256)', values: [[BigNumberish, BigNumberish, BigNumberish], BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'coins(int128)', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'coins(uint256)', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'exchange', values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'exchange_underlying', values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'get_dy', values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'get_dy_underlying', values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'underlying_coins(int128)', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'underlying_coins(uint256)', values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: 'add_liquidity(uint256[4],uint256)', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'add_liquidity(uint256[2],uint256)', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'add_liquidity(uint256[3],uint256)', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'coins(int128)', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'coins(uint256)', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'exchange', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'exchange_underlying', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'get_dy', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'get_dy_underlying', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'underlying_coins(int128)', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'underlying_coins(uint256)', data: BytesLike): Result;
+}
+export interface ICurveYPoolSwap extends BaseContract {
+    connect(runner?: ContractRunner | null): ICurveYPoolSwap;
+    waitForDeployment(): Promise<this>;
+    interface: ICurveYPoolSwapInterface;
+    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>;
+    "add_liquidity(uint256[4],uint256)": TypedContractMethod<[
+        _amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
+        _min_mint_amount: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    "add_liquidity(uint256[2],uint256)": TypedContractMethod<[
+        _amounts: [BigNumberish, BigNumberish],
+        _min_mint_amount: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    "add_liquidity(uint256[3],uint256)": TypedContractMethod<[
+        _amounts: [BigNumberish, BigNumberish, BigNumberish],
+        _min_mint_amount: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    "coins(int128)": TypedContractMethod<[
+        index: BigNumberish
+    ], [
+        string
+    ], 'view'>;
+    "coins(uint256)": TypedContractMethod<[
+        index: BigNumberish
+    ], [
+        string
+    ], 'view'>;
+    exchange: TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish,
+        min_dy: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    exchange_underlying: TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish,
+        min_dy: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    get_dy: TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish
+    ], [
+        bigint
+    ], 'view'>;
+    get_dy_underlying: TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish
+    ], [
+        bigint
+    ], 'view'>;
+    "underlying_coins(int128)": TypedContractMethod<[
+        index: BigNumberish
+    ], [
+        string
+    ], 'view'>;
+    "underlying_coins(uint256)": TypedContractMethod<[
+        index: BigNumberish
+    ], [
+        string
+    ], 'view'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'add_liquidity(uint256[4],uint256)'): TypedContractMethod<[
+        _amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
+        _min_mint_amount: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'add_liquidity(uint256[2],uint256)'): TypedContractMethod<[
+        _amounts: [BigNumberish, BigNumberish],
+        _min_mint_amount: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'add_liquidity(uint256[3],uint256)'): TypedContractMethod<[
+        _amounts: [BigNumberish, BigNumberish, BigNumberish],
+        _min_mint_amount: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'coins(int128)'): TypedContractMethod<[
+        index: BigNumberish
+    ], [
+        string
+    ], 'view'>;
+    getFunction(nameOrSignature: 'coins(uint256)'): TypedContractMethod<[
+        index: BigNumberish
+    ], [
+        string
+    ], 'view'>;
+    getFunction(nameOrSignature: 'exchange'): TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish,
+        min_dy: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'exchange_underlying'): TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish,
+        min_dy: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'get_dy'): TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'get_dy_underlying'): TypedContractMethod<[
+        i: BigNumberish,
+        j: BigNumberish,
+        dx: BigNumberish
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'underlying_coins(int128)'): TypedContractMethod<[
+        index: BigNumberish
+    ], [
+        string
+    ], 'view'>;
+    getFunction(nameOrSignature: 'underlying_coins(uint256)'): TypedContractMethod<[
+        index: BigNumberish
+    ], [
+        string
+    ], 'view'>;
+    filters: {};
+}

package/dist/types/typechain-types/psm/utils/zap/interfaces/ICurveYPool.sol/index.d.ts

@@ -0,0 +1,8 @@
+export type { ICurveY2PoolDeposit } from './ICurveY2PoolDeposit.js';
+export type { ICurveY2PoolSwap } from './ICurveY2PoolSwap.js';
+export type { ICurveY3PoolDeposit } from './ICurveY3PoolDeposit.js';
+export type { ICurveY3PoolSwap } from './ICurveY3PoolSwap.js';
+export type { ICurveY4PoolDeposit } from './ICurveY4PoolDeposit.js';
+export type { ICurveY4PoolSwap } from './ICurveY4PoolSwap.js';
+export type { ICurveYPoolDeposit } from './ICurveYPoolDeposit.js';
+export type { ICurveYPoolSwap } from './ICurveYPoolSwap.js';

package/dist/types/typechain-types/psm/utils/zap/interfaces/ILidoStETH.d.ts

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

package/dist/types/typechain-types/psm/utils/zap/interfaces/ILidoWstETH.d.ts

@@ -0,0 +1,89 @@
+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 ILidoWstETHInterface extends Interface {
+    getFunction(nameOrSignature: "getStETHByWstETH" | "getWstETHByStETH" | "stEthPerToken" | "tokensPerStEth" | "unwrap" | "wrap"): FunctionFragment;
+    encodeFunctionData(functionFragment: 'getStETHByWstETH', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'getWstETHByStETH', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'stEthPerToken', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'tokensPerStEth', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'unwrap', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'wrap', values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: 'getStETHByWstETH', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getWstETHByStETH', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'stEthPerToken', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'tokensPerStEth', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'unwrap', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'wrap', data: BytesLike): Result;
+}
+export interface ILidoWstETH extends BaseContract {
+    connect(runner?: ContractRunner | null): ILidoWstETH;
+    waitForDeployment(): Promise<this>;
+    interface: ILidoWstETHInterface;
+    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>;
+    getStETHByWstETH: TypedContractMethod<[
+        _wstETHAmount: BigNumberish
+    ], [
+        bigint
+    ], 'view'>;
+    getWstETHByStETH: TypedContractMethod<[
+        _stETHAmount: BigNumberish
+    ], [
+        bigint
+    ], 'view'>;
+    stEthPerToken: TypedContractMethod<[
+    ], [
+        bigint
+    ], 'view'>;
+    tokensPerStEth: TypedContractMethod<[
+    ], [
+        bigint
+    ], 'view'>;
+    unwrap: TypedContractMethod<[
+        _wstETHAmount: BigNumberish
+    ], [
+        bigint
+    ], 'nonpayable'>;
+    wrap: TypedContractMethod<[
+        _stETHAmount: BigNumberish
+    ], [
+        bigint
+    ], 'nonpayable'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'getStETHByWstETH'): TypedContractMethod<[
+        _wstETHAmount: BigNumberish
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'getWstETHByStETH'): TypedContractMethod<[
+        _stETHAmount: BigNumberish
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'stEthPerToken'): TypedContractMethod<[
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'tokensPerStEth'): TypedContractMethod<[
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'unwrap'): TypedContractMethod<[
+        _wstETHAmount: BigNumberish
+    ], [
+        bigint
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'wrap'): TypedContractMethod<[
+        _stETHAmount: BigNumberish
+    ], [
+        bigint
+    ], 'nonpayable'>;
+    filters: {};
+}

package/dist/types/typechain-types/psm/utils/zap/interfaces/IUniswapV2Pair.d.ts

@@ -0,0 +1,103 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common.js";
+export interface IUniswapV2PairInterface extends Interface {
+    getFunction(nameOrSignature: "executeVirtualOrders" | "getAmountOut" | "getReserves" | "swap" | "token0" | "token1"): FunctionFragment;
+    encodeFunctionData(functionFragment: 'executeVirtualOrders', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'getAmountOut', values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'getReserves', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'swap', values: [BigNumberish, BigNumberish, AddressLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: 'token0', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'token1', values?: undefined): string;
+    decodeFunctionResult(functionFragment: 'executeVirtualOrders', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getAmountOut', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getReserves', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'swap', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'token0', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'token1', data: BytesLike): Result;
+}
+export interface IUniswapV2Pair extends BaseContract {
+    connect(runner?: ContractRunner | null): IUniswapV2Pair;
+    waitForDeployment(): Promise<this>;
+    interface: IUniswapV2PairInterface;
+    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>;
+    executeVirtualOrders: TypedContractMethod<[
+        blockTimestamp: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    getAmountOut: TypedContractMethod<[
+        amountIn: BigNumberish,
+        tokenIn: AddressLike
+    ], [
+        bigint
+    ], 'view'>;
+    getReserves: TypedContractMethod<[
+    ], [
+        [bigint, bigint, bigint] & {
+            _reserve0: bigint;
+            _reserve1: bigint;
+            _blockTimestampLast: bigint;
+        }
+    ], 'view'>;
+    swap: TypedContractMethod<[
+        amount0Out: BigNumberish,
+        amount1Out: BigNumberish,
+        to: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], 'nonpayable'>;
+    token0: TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    token1: TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'executeVirtualOrders'): TypedContractMethod<[
+        blockTimestamp: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'getAmountOut'): TypedContractMethod<[
+        amountIn: BigNumberish,
+        tokenIn: AddressLike
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'getReserves'): TypedContractMethod<[
+    ], [
+        [bigint, bigint, bigint] & {
+            _reserve0: bigint;
+            _reserve1: bigint;
+            _blockTimestampLast: bigint;
+        }
+    ], 'view'>;
+    getFunction(nameOrSignature: 'swap'): TypedContractMethod<[
+        amount0Out: BigNumberish,
+        amount1Out: BigNumberish,
+        to: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'token0'): TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    getFunction(nameOrSignature: 'token1'): TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    filters: {};
+}

package/dist/types/typechain-types/psm/utils/zap/interfaces/IUniswapV3Pool.d.ts

@@ -0,0 +1,113 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common.js";
+export interface IUniswapV3PoolInterface extends Interface {
+    getFunction(nameOrSignature: "factory" | "fee" | "slot0" | "swap" | "token0" | "token1"): FunctionFragment;
+    encodeFunctionData(functionFragment: 'factory', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'fee', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'slot0', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'swap', values: [AddressLike, boolean, BigNumberish, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: 'token0', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'token1', values?: undefined): string;
+    decodeFunctionResult(functionFragment: 'factory', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'fee', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'slot0', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'swap', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'token0', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'token1', data: BytesLike): Result;
+}
+export interface IUniswapV3Pool extends BaseContract {
+    connect(runner?: ContractRunner | null): IUniswapV3Pool;
+    waitForDeployment(): Promise<this>;
+    interface: IUniswapV3PoolInterface;
+    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>;
+    factory: TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    fee: TypedContractMethod<[
+    ], [
+        bigint
+    ], 'view'>;
+    slot0: TypedContractMethod<[
+    ], [
+        [bigint, bigint, bigint, bigint, bigint, bigint, boolean] & {
+            sqrtPriceX96: bigint;
+            tick: bigint;
+            observationIndex: bigint;
+            observationCardinality: bigint;
+            observationCardinalityNext: bigint;
+            feeProtocol: bigint;
+            unlocked: boolean;
+        }
+    ], 'view'>;
+    swap: TypedContractMethod<[
+        recipient: AddressLike,
+        zeroForOne: boolean,
+        amountSpecified: BigNumberish,
+        sqrtPriceLimitX96: BigNumberish,
+        data: BytesLike
+    ], [
+        [bigint, bigint] & {
+            amount0: bigint;
+            amount1: bigint;
+        }
+    ], 'nonpayable'>;
+    token0: TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    token1: TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'factory'): TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    getFunction(nameOrSignature: 'fee'): TypedContractMethod<[
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'slot0'): TypedContractMethod<[
+    ], [
+        [bigint, bigint, bigint, bigint, bigint, bigint, boolean] & {
+            sqrtPriceX96: bigint;
+            tick: bigint;
+            observationIndex: bigint;
+            observationCardinality: bigint;
+            observationCardinalityNext: bigint;
+            feeProtocol: bigint;
+            unlocked: boolean;
+        }
+    ], 'view'>;
+    getFunction(nameOrSignature: 'swap'): TypedContractMethod<[
+        recipient: AddressLike,
+        zeroForOne: boolean,
+        amountSpecified: BigNumberish,
+        sqrtPriceLimitX96: BigNumberish,
+        data: BytesLike
+    ], [
+        [bigint, bigint] & {
+            amount0: bigint;
+            amount1: bigint;
+        }
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'token0'): TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    getFunction(nameOrSignature: 'token1'): TypedContractMethod<[
+    ], [
+        string
+    ], 'view'>;
+    filters: {};
+}

package/dist/types/typechain-types/psm/utils/zap/interfaces/IUniswapV3Router.d.ts

@@ -0,0 +1,55 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common.js";
+export declare namespace IUniswapV3Router {
+    type ExactInputSingleParamsStruct = {
+        tokenIn: AddressLike;
+        tokenOut: AddressLike;
+        fee: BigNumberish;
+        recipient: AddressLike;
+        deadline: BigNumberish;
+        amountIn: BigNumberish;
+        amountOutMinimum: BigNumberish;
+        sqrtPriceLimitX96: BigNumberish;
+    };
+    type ExactInputSingleParamsStructOutput = [tokenIn: string, tokenOut: string, fee: bigint, recipient: string, deadline: bigint, amountIn: bigint, amountOutMinimum: bigint, sqrtPriceLimitX96: bigint] & {
+        tokenIn: string;
+        tokenOut: string;
+        fee: bigint;
+        recipient: string;
+        deadline: bigint;
+        amountIn: bigint;
+        amountOutMinimum: bigint;
+        sqrtPriceLimitX96: bigint;
+    };
+}
+export interface IUniswapV3RouterInterface extends Interface {
+    getFunction(nameOrSignature: "exactInputSingle"): FunctionFragment;
+    encodeFunctionData(functionFragment: 'exactInputSingle', values: [IUniswapV3Router.ExactInputSingleParamsStruct]): string;
+    decodeFunctionResult(functionFragment: 'exactInputSingle', data: BytesLike): Result;
+}
+export interface IUniswapV3Router extends BaseContract {
+    connect(runner?: ContractRunner | null): IUniswapV3Router;
+    waitForDeployment(): Promise<this>;
+    interface: IUniswapV3RouterInterface;
+    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>;
+    exactInputSingle: TypedContractMethod<[
+        params: IUniswapV3Router.ExactInputSingleParamsStruct
+    ], [
+        bigint
+    ], 'nonpayable'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'exactInputSingle'): TypedContractMethod<[
+        params: IUniswapV3Router.ExactInputSingleParamsStruct
+    ], [
+        bigint
+    ], 'nonpayable'>;
+    filters: {};
+}

package/dist/types/typechain-types/psm/utils/zap/interfaces/IWETH.d.ts

@@ -0,0 +1,43 @@
+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 IWETHInterface extends Interface {
+    getFunction(nameOrSignature: "deposit" | "withdraw"): FunctionFragment;
+    encodeFunctionData(functionFragment: 'deposit', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'withdraw', values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result;
+}
+export interface IWETH extends BaseContract {
+    connect(runner?: ContractRunner | null): IWETH;
+    waitForDeployment(): Promise<this>;
+    interface: IWETHInterface;
+    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>;
+    deposit: TypedContractMethod<[
+    ], [
+        void
+    ], 'payable'>;
+    withdraw: TypedContractMethod<[
+        wad: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'deposit'): TypedContractMethod<[
+    ], [
+        void
+    ], 'payable'>;
+    getFunction(nameOrSignature: 'withdraw'): TypedContractMethod<[
+        wad: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
+    filters: {};
+}