@merkl/contracts 0.0.1

package/dist/src/PerpetualManagerFront.d.ts

@@ -0,0 +1,1505 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "./common";
+export type PairsStruct = {
+    owner: PromiseOrValue<string>;
+    netCashOutAmount: PromiseOrValue<BigNumberish>;
+};
+export type PairsStructOutput = [string, BigNumber] & {
+    owner: string;
+    netCashOutAmount: BigNumber;
+};
+export interface PerpetualManagerFrontInterface extends utils.Interface {
+    functions: {
+        "admin()": FunctionFragment;
+        "changeAdmin(address)": FunctionFragment;
+        "implementation()": FunctionFragment;
+        "upgradeTo(address)": FunctionFragment;
+        "upgradeToAndCall(address,bytes)": FunctionFragment;
+        "BASE_PARAMS()": FunctionFragment;
+        "BASE_TOKENS()": FunctionFragment;
+        "DEFAULT_ADMIN_ROLE()": FunctionFragment;
+        "GUARDIAN_ROLE()": FunctionFragment;
+        "POOLMANAGER_ROLE()": FunctionFragment;
+        "addToPerpetual(uint256,uint256)": FunctionFragment;
+        "approve(address,uint256)": FunctionFragment;
+        "balanceOf(address)": FunctionFragment;
+        "baseURI()": FunctionFragment;
+        "closePerpetual(uint256,address,uint256)": FunctionFragment;
+        "deployCollateral(address[],address,address,address)": FunctionFragment;
+        "earned(uint256)": FunctionFragment;
+        "forceClosePerpetuals(uint256[])": FunctionFragment;
+        "getApproved(uint256)": FunctionFragment;
+        "getCashOutAmount(uint256,uint256)": FunctionFragment;
+        "getReward(uint256)": FunctionFragment;
+        "getRoleAdmin(bytes32)": FunctionFragment;
+        "grantRole(bytes32,address)": FunctionFragment;
+        "haBonusMalusDeposit()": FunctionFragment;
+        "haBonusMalusWithdraw()": FunctionFragment;
+        "hasRole(bytes32,address)": FunctionFragment;
+        "initialize(address,address)": FunctionFragment;
+        "isApprovedForAll(address,address)": FunctionFragment;
+        "isApprovedOrOwner(address,uint256)": FunctionFragment;
+        "keeperFeesClosingCap()": FunctionFragment;
+        "keeperFeesLiquidationCap()": FunctionFragment;
+        "keeperFeesLiquidationRatio()": FunctionFragment;
+        "lastUpdateTime()": FunctionFragment;
+        "limitHAHedge()": FunctionFragment;
+        "liquidatePerpetuals(uint256[])": FunctionFragment;
+        "lockTime()": FunctionFragment;
+        "maintenanceMargin()": FunctionFragment;
+        "maxLeverage()": FunctionFragment;
+        "name()": FunctionFragment;
+        "notifyRewardAmount(uint256)": FunctionFragment;
+        "openPerpetual(address,uint256,uint256,uint256,uint256)": FunctionFragment;
+        "oracle()": FunctionFragment;
+        "ownerOf(uint256)": FunctionFragment;
+        "pause()": FunctionFragment;
+        "paused()": FunctionFragment;
+        "periodFinish()": FunctionFragment;
+        "perpetualData(uint256)": FunctionFragment;
+        "perpetualRewardPerTokenPaid(uint256)": FunctionFragment;
+        "poolManager()": FunctionFragment;
+        "recoverERC20(address,address,uint256)": FunctionFragment;
+        "removeFromPerpetual(uint256,uint256,address)": FunctionFragment;
+        "renounceRole(bytes32,address)": FunctionFragment;
+        "revokeRole(bytes32,address)": FunctionFragment;
+        "rewardPerTokenStored()": FunctionFragment;
+        "rewardRate()": FunctionFragment;
+        "rewardToken()": FunctionFragment;
+        "rewards(uint256)": FunctionFragment;
+        "rewardsDistribution()": FunctionFragment;
+        "rewardsDuration()": FunctionFragment;
+        "safeTransferFrom(address,address,uint256)": FunctionFragment;
+        "safeTransferFrom(address,address,uint256,bytes)": FunctionFragment;
+        "setApprovalForAll(address,bool)": FunctionFragment;
+        "setBaseURI(string)": FunctionFragment;
+        "setBoundsPerpetual(uint64,uint64)": FunctionFragment;
+        "setFeeKeeper(uint64,uint64)": FunctionFragment;
+        "setFeeManager(address)": FunctionFragment;
+        "setHAFees(uint64[],uint64[],uint8)": FunctionFragment;
+        "setKeeperFeesCap(uint256,uint256)": FunctionFragment;
+        "setKeeperFeesClosing(uint64[],uint64[])": FunctionFragment;
+        "setKeeperFeesLiquidationRatio(uint64)": FunctionFragment;
+        "setLockTime(uint64)": FunctionFragment;
+        "setNewRewardsDistribution(address)": FunctionFragment;
+        "setOracle(address)": FunctionFragment;
+        "setRewardDistribution(uint256,address)": FunctionFragment;
+        "setTargetAndLimitHAHedge(uint64,uint64)": FunctionFragment;
+        "supportsInterface(bytes4)": FunctionFragment;
+        "symbol()": FunctionFragment;
+        "targetHAHedge()": FunctionFragment;
+        "tokenURI(uint256)": FunctionFragment;
+        "totalHedgeAmount()": FunctionFragment;
+        "transferFrom(address,address,uint256)": FunctionFragment;
+        "unpause()": FunctionFragment;
+        "xHAFeesDeposit(uint256)": FunctionFragment;
+        "xHAFeesWithdraw(uint256)": FunctionFragment;
+        "xKeeperFeesClosing(uint256)": FunctionFragment;
+        "yHAFeesDeposit(uint256)": FunctionFragment;
+        "yHAFeesWithdraw(uint256)": FunctionFragment;
+        "yKeeperFeesClosing(uint256)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "admin" | "changeAdmin" | "implementation" | "upgradeTo" | "upgradeToAndCall" | "BASE_PARAMS" | "BASE_TOKENS" | "DEFAULT_ADMIN_ROLE" | "GUARDIAN_ROLE" | "POOLMANAGER_ROLE" | "addToPerpetual" | "approve" | "balanceOf" | "baseURI" | "closePerpetual" | "deployCollateral" | "earned" | "forceClosePerpetuals" | "getApproved" | "getCashOutAmount" | "getReward" | "getRoleAdmin" | "grantRole" | "haBonusMalusDeposit" | "haBonusMalusWithdraw" | "hasRole" | "initialize" | "isApprovedForAll" | "isApprovedOrOwner" | "keeperFeesClosingCap" | "keeperFeesLiquidationCap" | "keeperFeesLiquidationRatio" | "lastUpdateTime" | "limitHAHedge" | "liquidatePerpetuals" | "lockTime" | "maintenanceMargin" | "maxLeverage" | "name" | "notifyRewardAmount" | "openPerpetual" | "oracle" | "ownerOf" | "pause" | "paused" | "periodFinish" | "perpetualData" | "perpetualRewardPerTokenPaid" | "poolManager" | "recoverERC20" | "removeFromPerpetual" | "renounceRole" | "revokeRole" | "rewardPerTokenStored" | "rewardRate" | "rewardToken" | "rewards" | "rewardsDistribution" | "rewardsDuration" | "safeTransferFrom(address,address,uint256)" | "safeTransferFrom(address,address,uint256,bytes)" | "setApprovalForAll" | "setBaseURI" | "setBoundsPerpetual" | "setFeeKeeper" | "setFeeManager" | "setHAFees" | "setKeeperFeesCap" | "setKeeperFeesClosing" | "setKeeperFeesLiquidationRatio" | "setLockTime" | "setNewRewardsDistribution" | "setOracle" | "setRewardDistribution" | "setTargetAndLimitHAHedge" | "supportsInterface" | "symbol" | "targetHAHedge" | "tokenURI" | "totalHedgeAmount" | "transferFrom" | "unpause" | "xHAFeesDeposit" | "xHAFeesWithdraw" | "xKeeperFeesClosing" | "yHAFeesDeposit" | "yHAFeesWithdraw" | "yKeeperFeesClosing"): FunctionFragment;
+    encodeFunctionData(functionFragment: "admin", values?: undefined): string;
+    encodeFunctionData(functionFragment: "changeAdmin", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "upgradeTo", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "upgradeToAndCall", values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "BASE_PARAMS", values?: undefined): string;
+    encodeFunctionData(functionFragment: "BASE_TOKENS", values?: undefined): string;
+    encodeFunctionData(functionFragment: "DEFAULT_ADMIN_ROLE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "GUARDIAN_ROLE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "POOLMANAGER_ROLE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "addToPerpetual", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "approve", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "baseURI", values?: undefined): string;
+    encodeFunctionData(functionFragment: "closePerpetual", values: [
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "deployCollateral", values: [
+        PromiseOrValue<string>[],
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<string>
+    ]): string;
+    encodeFunctionData(functionFragment: "earned", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "forceClosePerpetuals", values: [PromiseOrValue<BigNumberish>[]]): string;
+    encodeFunctionData(functionFragment: "getApproved", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "getCashOutAmount", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "getReward", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "getRoleAdmin", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "grantRole", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "haBonusMalusDeposit", values?: undefined): string;
+    encodeFunctionData(functionFragment: "haBonusMalusWithdraw", values?: undefined): string;
+    encodeFunctionData(functionFragment: "hasRole", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "initialize", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "isApprovedForAll", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "isApprovedOrOwner", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "keeperFeesClosingCap", values?: undefined): string;
+    encodeFunctionData(functionFragment: "keeperFeesLiquidationCap", values?: undefined): string;
+    encodeFunctionData(functionFragment: "keeperFeesLiquidationRatio", values?: undefined): string;
+    encodeFunctionData(functionFragment: "lastUpdateTime", values?: undefined): string;
+    encodeFunctionData(functionFragment: "limitHAHedge", values?: undefined): string;
+    encodeFunctionData(functionFragment: "liquidatePerpetuals", values: [PromiseOrValue<BigNumberish>[]]): string;
+    encodeFunctionData(functionFragment: "lockTime", values?: undefined): string;
+    encodeFunctionData(functionFragment: "maintenanceMargin", values?: undefined): string;
+    encodeFunctionData(functionFragment: "maxLeverage", values?: undefined): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "notifyRewardAmount", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "openPerpetual", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "oracle", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ownerOf", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "pause", values?: undefined): string;
+    encodeFunctionData(functionFragment: "paused", values?: undefined): string;
+    encodeFunctionData(functionFragment: "periodFinish", values?: undefined): string;
+    encodeFunctionData(functionFragment: "perpetualData", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "perpetualRewardPerTokenPaid", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "poolManager", values?: undefined): string;
+    encodeFunctionData(functionFragment: "recoverERC20", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "removeFromPerpetual", values: [
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>
+    ]): string;
+    encodeFunctionData(functionFragment: "renounceRole", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "revokeRole", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "rewardPerTokenStored", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewardRate", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewardToken", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewards", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "rewardsDistribution", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewardsDuration", values?: undefined): string;
+    encodeFunctionData(functionFragment: "safeTransferFrom(address,address,uint256)", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "safeTransferFrom(address,address,uint256,bytes)", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "setApprovalForAll", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
+    encodeFunctionData(functionFragment: "setBaseURI", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setBoundsPerpetual", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "setFeeKeeper", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "setFeeManager", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setHAFees", values: [
+        PromiseOrValue<BigNumberish>[],
+        PromiseOrValue<BigNumberish>[],
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "setKeeperFeesCap", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "setKeeperFeesClosing", values: [PromiseOrValue<BigNumberish>[], PromiseOrValue<BigNumberish>[]]): string;
+    encodeFunctionData(functionFragment: "setKeeperFeesLiquidationRatio", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "setLockTime", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "setNewRewardsDistribution", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setOracle", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setRewardDistribution", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setTargetAndLimitHAHedge", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "supportsInterface", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "targetHAHedge", values?: undefined): string;
+    encodeFunctionData(functionFragment: "tokenURI", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "totalHedgeAmount", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
+    encodeFunctionData(functionFragment: "xHAFeesDeposit", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "xHAFeesWithdraw", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "xKeeperFeesClosing", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "yHAFeesDeposit", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "yHAFeesWithdraw", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "yKeeperFeesClosing", values: [PromiseOrValue<BigNumberish>]): string;
+    decodeFunctionResult(functionFragment: "admin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeAdmin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeToAndCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "BASE_PARAMS", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "BASE_TOKENS", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "DEFAULT_ADMIN_ROLE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "GUARDIAN_ROLE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "POOLMANAGER_ROLE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "addToPerpetual", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "baseURI", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "closePerpetual", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deployCollateral", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "earned", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "forceClosePerpetuals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getApproved", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCashOutAmount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getReward", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRoleAdmin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "haBonusMalusDeposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "haBonusMalusWithdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isApprovedForAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isApprovedOrOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "keeperFeesClosingCap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "keeperFeesLiquidationCap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "keeperFeesLiquidationRatio", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lastUpdateTime", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "limitHAHedge", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "liquidatePerpetuals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lockTime", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "maintenanceMargin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "maxLeverage", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "notifyRewardAmount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "openPerpetual", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "oracle", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "periodFinish", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "perpetualData", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "perpetualRewardPerTokenPaid", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "poolManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recoverERC20", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeFromPerpetual", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceRole", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardPerTokenStored", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardsDistribution", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardsDuration", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "safeTransferFrom(address,address,uint256)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "safeTransferFrom(address,address,uint256,bytes)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setApprovalForAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setBaseURI", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setBoundsPerpetual", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setFeeKeeper", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setFeeManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setHAFees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setKeeperFeesCap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setKeeperFeesClosing", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setKeeperFeesLiquidationRatio", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setLockTime", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setNewRewardsDistribution", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setOracle", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setRewardDistribution", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTargetAndLimitHAHedge", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "targetHAHedge", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tokenURI", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalHedgeAmount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "xHAFeesDeposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "xHAFeesWithdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "xKeeperFeesClosing", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "yHAFeesDeposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "yHAFeesWithdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "yKeeperFeesClosing", data: BytesLike): Result;
+    events: {
+        "AdminChanged(address,address)": EventFragment;
+        "BeaconUpgraded(address)": EventFragment;
+        "Upgraded(address)": EventFragment;
+        "Approval(address,address,uint256)": EventFragment;
+        "ApprovalForAll(address,address,bool)": EventFragment;
+        "BaseURIUpdated(string)": EventFragment;
+        "BoundsPerpetualUpdated(uint64,uint64)": EventFragment;
+        "HAFeesUpdated(uint64[],uint64[],uint8)": EventFragment;
+        "KeeperFeesCapUpdated(uint256,uint256)": EventFragment;
+        "KeeperFeesClosingUpdated(uint64[],uint64[])": EventFragment;
+        "KeeperFeesLiquidationRatioUpdated(uint64)": EventFragment;
+        "KeeperTransferred(address,uint256)": EventFragment;
+        "LockTimeUpdated(uint64)": EventFragment;
+        "Paused(address)": EventFragment;
+        "PerpetualClosed(uint256,uint256)": EventFragment;
+        "PerpetualOpened(uint256,uint256,uint256,uint256)": EventFragment;
+        "PerpetualUpdated(uint256,uint256)": EventFragment;
+        "PerpetualsForceClosed(uint256[],tuple[],address,uint256)": EventFragment;
+        "Recovered(address,address,uint256)": EventFragment;
+        "RewardAdded(uint256)": EventFragment;
+        "RewardPaid(address,uint256)": EventFragment;
+        "RewardsDistributionDurationUpdated(uint256,address)": EventFragment;
+        "RewardsDistributionUpdated(address)": EventFragment;
+        "RoleAdminChanged(bytes32,bytes32,bytes32)": EventFragment;
+        "RoleGranted(bytes32,address,address)": EventFragment;
+        "RoleRevoked(bytes32,address,address)": EventFragment;
+        "TargetAndLimitHAHedgeUpdated(uint64,uint64)": EventFragment;
+        "Transfer(address,address,uint256)": EventFragment;
+        "Unpaused(address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "BaseURIUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "BoundsPerpetualUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "HAFeesUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "KeeperFeesCapUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "KeeperFeesClosingUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "KeeperFeesLiquidationRatioUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "KeeperTransferred"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "LockTimeUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "PerpetualClosed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "PerpetualOpened"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "PerpetualUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "PerpetualsForceClosed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Recovered"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardAdded"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardPaid"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardsDistributionDurationUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardsDistributionUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RoleAdminChanged"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RoleGranted"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RoleRevoked"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TargetAndLimitHAHedgeUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
+}
+export interface AdminChangedEventObject {
+    previousAdmin: string;
+    newAdmin: string;
+}
+export type AdminChangedEvent = TypedEvent<[
+    string,
+    string
+], AdminChangedEventObject>;
+export type AdminChangedEventFilter = TypedEventFilter<AdminChangedEvent>;
+export interface BeaconUpgradedEventObject {
+    beacon: string;
+}
+export type BeaconUpgradedEvent = TypedEvent<[
+    string
+], BeaconUpgradedEventObject>;
+export type BeaconUpgradedEventFilter = TypedEventFilter<BeaconUpgradedEvent>;
+export interface UpgradedEventObject {
+    implementation: string;
+}
+export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>;
+export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
+export interface ApprovalEventObject {
+    owner: string;
+    approved: string;
+    tokenId: BigNumber;
+}
+export type ApprovalEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], ApprovalEventObject>;
+export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
+export interface ApprovalForAllEventObject {
+    owner: string;
+    operator: string;
+    approved: boolean;
+}
+export type ApprovalForAllEvent = TypedEvent<[
+    string,
+    string,
+    boolean
+], ApprovalForAllEventObject>;
+export type ApprovalForAllEventFilter = TypedEventFilter<ApprovalForAllEvent>;
+export interface BaseURIUpdatedEventObject {
+    _baseURI: string;
+}
+export type BaseURIUpdatedEvent = TypedEvent<[
+    string
+], BaseURIUpdatedEventObject>;
+export type BaseURIUpdatedEventFilter = TypedEventFilter<BaseURIUpdatedEvent>;
+export interface BoundsPerpetualUpdatedEventObject {
+    _maxLeverage: BigNumber;
+    _maintenanceMargin: BigNumber;
+}
+export type BoundsPerpetualUpdatedEvent = TypedEvent<[
+    BigNumber,
+    BigNumber
+], BoundsPerpetualUpdatedEventObject>;
+export type BoundsPerpetualUpdatedEventFilter = TypedEventFilter<BoundsPerpetualUpdatedEvent>;
+export interface HAFeesUpdatedEventObject {
+    _xHAFees: BigNumber[];
+    _yHAFees: BigNumber[];
+    deposit: number;
+}
+export type HAFeesUpdatedEvent = TypedEvent<[
+    BigNumber[],
+    BigNumber[],
+    number
+], HAFeesUpdatedEventObject>;
+export type HAFeesUpdatedEventFilter = TypedEventFilter<HAFeesUpdatedEvent>;
+export interface KeeperFeesCapUpdatedEventObject {
+    _keeperFeesLiquidationCap: BigNumber;
+    _keeperFeesClosingCap: BigNumber;
+}
+export type KeeperFeesCapUpdatedEvent = TypedEvent<[
+    BigNumber,
+    BigNumber
+], KeeperFeesCapUpdatedEventObject>;
+export type KeeperFeesCapUpdatedEventFilter = TypedEventFilter<KeeperFeesCapUpdatedEvent>;
+export interface KeeperFeesClosingUpdatedEventObject {
+    xKeeperFeesClosing: BigNumber[];
+    yKeeperFeesClosing: BigNumber[];
+}
+export type KeeperFeesClosingUpdatedEvent = TypedEvent<[
+    BigNumber[],
+    BigNumber[]
+], KeeperFeesClosingUpdatedEventObject>;
+export type KeeperFeesClosingUpdatedEventFilter = TypedEventFilter<KeeperFeesClosingUpdatedEvent>;
+export interface KeeperFeesLiquidationRatioUpdatedEventObject {
+    _keeperFeesLiquidationRatio: BigNumber;
+}
+export type KeeperFeesLiquidationRatioUpdatedEvent = TypedEvent<[
+    BigNumber
+], KeeperFeesLiquidationRatioUpdatedEventObject>;
+export type KeeperFeesLiquidationRatioUpdatedEventFilter = TypedEventFilter<KeeperFeesLiquidationRatioUpdatedEvent>;
+export interface KeeperTransferredEventObject {
+    keeperAddress: string;
+    liquidationFees: BigNumber;
+}
+export type KeeperTransferredEvent = TypedEvent<[
+    string,
+    BigNumber
+], KeeperTransferredEventObject>;
+export type KeeperTransferredEventFilter = TypedEventFilter<KeeperTransferredEvent>;
+export interface LockTimeUpdatedEventObject {
+    _lockTime: BigNumber;
+}
+export type LockTimeUpdatedEvent = TypedEvent<[
+    BigNumber
+], LockTimeUpdatedEventObject>;
+export type LockTimeUpdatedEventFilter = TypedEventFilter<LockTimeUpdatedEvent>;
+export interface PausedEventObject {
+    account: string;
+}
+export type PausedEvent = TypedEvent<[string], PausedEventObject>;
+export type PausedEventFilter = TypedEventFilter<PausedEvent>;
+export interface PerpetualClosedEventObject {
+    _perpetualID: BigNumber;
+    _closeAmount: BigNumber;
+}
+export type PerpetualClosedEvent = TypedEvent<[
+    BigNumber,
+    BigNumber
+], PerpetualClosedEventObject>;
+export type PerpetualClosedEventFilter = TypedEventFilter<PerpetualClosedEvent>;
+export interface PerpetualOpenedEventObject {
+    _perpetualID: BigNumber;
+    _entryRate: BigNumber;
+    _margin: BigNumber;
+    _committedAmount: BigNumber;
+}
+export type PerpetualOpenedEvent = TypedEvent<[
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], PerpetualOpenedEventObject>;
+export type PerpetualOpenedEventFilter = TypedEventFilter<PerpetualOpenedEvent>;
+export interface PerpetualUpdatedEventObject {
+    _perpetualID: BigNumber;
+    _margin: BigNumber;
+}
+export type PerpetualUpdatedEvent = TypedEvent<[
+    BigNumber,
+    BigNumber
+], PerpetualUpdatedEventObject>;
+export type PerpetualUpdatedEventFilter = TypedEventFilter<PerpetualUpdatedEvent>;
+export interface PerpetualsForceClosedEventObject {
+    perpetualIDs: BigNumber[];
+    ownerAndCashOut: PairsStructOutput[];
+    keeper: string;
+    reward: BigNumber;
+}
+export type PerpetualsForceClosedEvent = TypedEvent<[
+    BigNumber[],
+    PairsStructOutput[],
+    string,
+    BigNumber
+], PerpetualsForceClosedEventObject>;
+export type PerpetualsForceClosedEventFilter = TypedEventFilter<PerpetualsForceClosedEvent>;
+export interface RecoveredEventObject {
+    tokenAddress: string;
+    to: string;
+    amount: BigNumber;
+}
+export type RecoveredEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], RecoveredEventObject>;
+export type RecoveredEventFilter = TypedEventFilter<RecoveredEvent>;
+export interface RewardAddedEventObject {
+    _reward: BigNumber;
+}
+export type RewardAddedEvent = TypedEvent<[BigNumber], RewardAddedEventObject>;
+export type RewardAddedEventFilter = TypedEventFilter<RewardAddedEvent>;
+export interface RewardPaidEventObject {
+    _user: string;
+    _reward: BigNumber;
+}
+export type RewardPaidEvent = TypedEvent<[
+    string,
+    BigNumber
+], RewardPaidEventObject>;
+export type RewardPaidEventFilter = TypedEventFilter<RewardPaidEvent>;
+export interface RewardsDistributionDurationUpdatedEventObject {
+    _rewardsDuration: BigNumber;
+    _rewardsDistributor: string;
+}
+export type RewardsDistributionDurationUpdatedEvent = TypedEvent<[
+    BigNumber,
+    string
+], RewardsDistributionDurationUpdatedEventObject>;
+export type RewardsDistributionDurationUpdatedEventFilter = TypedEventFilter<RewardsDistributionDurationUpdatedEvent>;
+export interface RewardsDistributionUpdatedEventObject {
+    _rewardsDistributor: string;
+}
+export type RewardsDistributionUpdatedEvent = TypedEvent<[
+    string
+], RewardsDistributionUpdatedEventObject>;
+export type RewardsDistributionUpdatedEventFilter = TypedEventFilter<RewardsDistributionUpdatedEvent>;
+export interface RoleAdminChangedEventObject {
+    role: string;
+    previousAdminRole: string;
+    newAdminRole: string;
+}
+export type RoleAdminChangedEvent = TypedEvent<[
+    string,
+    string,
+    string
+], RoleAdminChangedEventObject>;
+export type RoleAdminChangedEventFilter = TypedEventFilter<RoleAdminChangedEvent>;
+export interface RoleGrantedEventObject {
+    role: string;
+    account: string;
+    sender: string;
+}
+export type RoleGrantedEvent = TypedEvent<[
+    string,
+    string,
+    string
+], RoleGrantedEventObject>;
+export type RoleGrantedEventFilter = TypedEventFilter<RoleGrantedEvent>;
+export interface RoleRevokedEventObject {
+    role: string;
+    account: string;
+    sender: string;
+}
+export type RoleRevokedEvent = TypedEvent<[
+    string,
+    string,
+    string
+], RoleRevokedEventObject>;
+export type RoleRevokedEventFilter = TypedEventFilter<RoleRevokedEvent>;
+export interface TargetAndLimitHAHedgeUpdatedEventObject {
+    _targetHAHedge: BigNumber;
+    _limitHAHedge: BigNumber;
+}
+export type TargetAndLimitHAHedgeUpdatedEvent = TypedEvent<[
+    BigNumber,
+    BigNumber
+], TargetAndLimitHAHedgeUpdatedEventObject>;
+export type TargetAndLimitHAHedgeUpdatedEventFilter = TypedEventFilter<TargetAndLimitHAHedgeUpdatedEvent>;
+export interface TransferEventObject {
+    from: string;
+    to: string;
+    tokenId: BigNumber;
+}
+export type TransferEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], TransferEventObject>;
+export type TransferEventFilter = TypedEventFilter<TransferEvent>;
+export interface UnpausedEventObject {
+    account: string;
+}
+export type UnpausedEvent = TypedEvent<[string], UnpausedEventObject>;
+export type UnpausedEventFilter = TypedEventFilter<UnpausedEvent>;
+export interface PerpetualManagerFront extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: PerpetualManagerFrontInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        admin(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        changeAdmin(newAdmin: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        implementation(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        BASE_PARAMS(overrides?: CallOverrides): Promise<[BigNumber]>;
+        BASE_TOKENS(overrides?: CallOverrides): Promise<[BigNumber]>;
+        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>;
+        GUARDIAN_ROLE(overrides?: CallOverrides): Promise<[string]>;
+        POOLMANAGER_ROLE(overrides?: CallOverrides): Promise<[string]>;
+        addToPerpetual(perpetualID: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        approve(to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        balanceOf(owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        baseURI(overrides?: CallOverrides): Promise<[string]>;
+        closePerpetual(perpetualID: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, minCashOutAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        deployCollateral(governorList: PromiseOrValue<string>[], guardian: PromiseOrValue<string>, feeManager_: PromiseOrValue<string>, oracle_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        earned(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        forceClosePerpetuals(perpetualIDs: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        getApproved(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        getCashOutAmount(perpetualID: PromiseOrValue<BigNumberish>, rate: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>;
+        getReward(perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        getRoleAdmin(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string]>;
+        grantRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        haBonusMalusDeposit(overrides?: CallOverrides): Promise<[BigNumber]>;
+        haBonusMalusWithdraw(overrides?: CallOverrides): Promise<[BigNumber]>;
+        hasRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        initialize(poolManager_: PromiseOrValue<string>, rewardToken_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        isApprovedForAll(owner: PromiseOrValue<string>, operator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        isApprovedOrOwner(spender: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[boolean]>;
+        keeperFeesClosingCap(overrides?: CallOverrides): Promise<[BigNumber]>;
+        keeperFeesLiquidationCap(overrides?: CallOverrides): Promise<[BigNumber]>;
+        keeperFeesLiquidationRatio(overrides?: CallOverrides): Promise<[BigNumber]>;
+        lastUpdateTime(overrides?: CallOverrides): Promise<[BigNumber]>;
+        limitHAHedge(overrides?: CallOverrides): Promise<[BigNumber]>;
+        liquidatePerpetuals(perpetualIDs: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        lockTime(overrides?: CallOverrides): Promise<[BigNumber]>;
+        maintenanceMargin(overrides?: CallOverrides): Promise<[BigNumber]>;
+        maxLeverage(overrides?: CallOverrides): Promise<[BigNumber]>;
+        name(overrides?: CallOverrides): Promise<[string]>;
+        notifyRewardAmount(reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        openPerpetual(owner: PromiseOrValue<string>, margin: PromiseOrValue<BigNumberish>, committedAmount: PromiseOrValue<BigNumberish>, maxOracleRate: PromiseOrValue<BigNumberish>, minNetMargin: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        oracle(overrides?: CallOverrides): Promise<[string]>;
+        ownerOf(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        pause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        paused(overrides?: CallOverrides): Promise<[boolean]>;
+        periodFinish(overrides?: CallOverrides): Promise<[BigNumber]>;
+        perpetualData(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            entryRate: BigNumber;
+            entryTimestamp: BigNumber;
+            margin: BigNumber;
+            committedAmount: BigNumber;
+        }>;
+        perpetualRewardPerTokenPaid(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        poolManager(overrides?: CallOverrides): Promise<[string]>;
+        recoverERC20(tokenAddress: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        removeFromPerpetual(perpetualID: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        renounceRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        revokeRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        rewardPerTokenStored(overrides?: CallOverrides): Promise<[BigNumber]>;
+        rewardRate(overrides?: CallOverrides): Promise<[BigNumber]>;
+        rewardToken(overrides?: CallOverrides): Promise<[string]>;
+        rewards(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        rewardsDistribution(overrides?: CallOverrides): Promise<[string]>;
+        rewardsDuration(overrides?: CallOverrides): Promise<[BigNumber]>;
+        "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, _data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setApprovalForAll(operator: PromiseOrValue<string>, approved: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setBaseURI(_baseURI: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setBoundsPerpetual(_maxLeverage: PromiseOrValue<BigNumberish>, _maintenanceMargin: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setFeeKeeper(feeDeposit: PromiseOrValue<BigNumberish>, feeWithdraw: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setFeeManager(feeManager_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setHAFees(_xHAFees: PromiseOrValue<BigNumberish>[], _yHAFees: PromiseOrValue<BigNumberish>[], deposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setKeeperFeesCap(_keeperFeesLiquidationCap: PromiseOrValue<BigNumberish>, _keeperFeesClosingCap: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setKeeperFeesClosing(_xKeeperFeesClosing: PromiseOrValue<BigNumberish>[], _yKeeperFeesClosing: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setKeeperFeesLiquidationRatio(_keeperFeesLiquidationRatio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setLockTime(_lockTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setNewRewardsDistribution(_rewardsDistribution: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setOracle(oracle_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setRewardDistribution(_rewardsDuration: PromiseOrValue<BigNumberish>, _rewardsDistribution: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setTargetAndLimitHAHedge(_targetHAHedge: PromiseOrValue<BigNumberish>, _limitHAHedge: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean]>;
+        symbol(overrides?: CallOverrides): Promise<[string]>;
+        targetHAHedge(overrides?: CallOverrides): Promise<[BigNumber]>;
+        tokenURI(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        totalHedgeAmount(overrides?: CallOverrides): Promise<[BigNumber]>;
+        transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        unpause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        xHAFeesDeposit(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        xHAFeesWithdraw(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        xKeeperFeesClosing(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        yHAFeesDeposit(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        yHAFeesWithdraw(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        yKeeperFeesClosing(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+    };
+    admin(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    changeAdmin(newAdmin: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    implementation(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    BASE_PARAMS(overrides?: CallOverrides): Promise<BigNumber>;
+    BASE_TOKENS(overrides?: CallOverrides): Promise<BigNumber>;
+    DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
+    GUARDIAN_ROLE(overrides?: CallOverrides): Promise<string>;
+    POOLMANAGER_ROLE(overrides?: CallOverrides): Promise<string>;
+    addToPerpetual(perpetualID: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    approve(to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    balanceOf(owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    baseURI(overrides?: CallOverrides): Promise<string>;
+    closePerpetual(perpetualID: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, minCashOutAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    deployCollateral(governorList: PromiseOrValue<string>[], guardian: PromiseOrValue<string>, feeManager_: PromiseOrValue<string>, oracle_: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    earned(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    forceClosePerpetuals(perpetualIDs: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    getApproved(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    getCashOutAmount(perpetualID: PromiseOrValue<BigNumberish>, rate: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>;
+    getReward(perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    getRoleAdmin(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    grantRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    haBonusMalusDeposit(overrides?: CallOverrides): Promise<BigNumber>;
+    haBonusMalusWithdraw(overrides?: CallOverrides): Promise<BigNumber>;
+    hasRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    initialize(poolManager_: PromiseOrValue<string>, rewardToken_: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    isApprovedForAll(owner: PromiseOrValue<string>, operator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    isApprovedOrOwner(spender: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+    keeperFeesClosingCap(overrides?: CallOverrides): Promise<BigNumber>;
+    keeperFeesLiquidationCap(overrides?: CallOverrides): Promise<BigNumber>;
+    keeperFeesLiquidationRatio(overrides?: CallOverrides): Promise<BigNumber>;
+    lastUpdateTime(overrides?: CallOverrides): Promise<BigNumber>;
+    limitHAHedge(overrides?: CallOverrides): Promise<BigNumber>;
+    liquidatePerpetuals(perpetualIDs: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    lockTime(overrides?: CallOverrides): Promise<BigNumber>;
+    maintenanceMargin(overrides?: CallOverrides): Promise<BigNumber>;
+    maxLeverage(overrides?: CallOverrides): Promise<BigNumber>;
+    name(overrides?: CallOverrides): Promise<string>;
+    notifyRewardAmount(reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    openPerpetual(owner: PromiseOrValue<string>, margin: PromiseOrValue<BigNumberish>, committedAmount: PromiseOrValue<BigNumberish>, maxOracleRate: PromiseOrValue<BigNumberish>, minNetMargin: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    oracle(overrides?: CallOverrides): Promise<string>;
+    ownerOf(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    pause(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    paused(overrides?: CallOverrides): Promise<boolean>;
+    periodFinish(overrides?: CallOverrides): Promise<BigNumber>;
+    perpetualData(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber
+    ] & {
+        entryRate: BigNumber;
+        entryTimestamp: BigNumber;
+        margin: BigNumber;
+        committedAmount: BigNumber;
+    }>;
+    perpetualRewardPerTokenPaid(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    poolManager(overrides?: CallOverrides): Promise<string>;
+    recoverERC20(tokenAddress: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    removeFromPerpetual(perpetualID: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    renounceRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    revokeRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    rewardPerTokenStored(overrides?: CallOverrides): Promise<BigNumber>;
+    rewardRate(overrides?: CallOverrides): Promise<BigNumber>;
+    rewardToken(overrides?: CallOverrides): Promise<string>;
+    rewards(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    rewardsDistribution(overrides?: CallOverrides): Promise<string>;
+    rewardsDuration(overrides?: CallOverrides): Promise<BigNumber>;
+    "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, _data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setApprovalForAll(operator: PromiseOrValue<string>, approved: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setBaseURI(_baseURI: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setBoundsPerpetual(_maxLeverage: PromiseOrValue<BigNumberish>, _maintenanceMargin: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setFeeKeeper(feeDeposit: PromiseOrValue<BigNumberish>, feeWithdraw: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setFeeManager(feeManager_: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setHAFees(_xHAFees: PromiseOrValue<BigNumberish>[], _yHAFees: PromiseOrValue<BigNumberish>[], deposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setKeeperFeesCap(_keeperFeesLiquidationCap: PromiseOrValue<BigNumberish>, _keeperFeesClosingCap: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setKeeperFeesClosing(_xKeeperFeesClosing: PromiseOrValue<BigNumberish>[], _yKeeperFeesClosing: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setKeeperFeesLiquidationRatio(_keeperFeesLiquidationRatio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setLockTime(_lockTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setNewRewardsDistribution(_rewardsDistribution: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setOracle(oracle_: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setRewardDistribution(_rewardsDuration: PromiseOrValue<BigNumberish>, _rewardsDistribution: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setTargetAndLimitHAHedge(_targetHAHedge: PromiseOrValue<BigNumberish>, _limitHAHedge: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    symbol(overrides?: CallOverrides): Promise<string>;
+    targetHAHedge(overrides?: CallOverrides): Promise<BigNumber>;
+    tokenURI(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    totalHedgeAmount(overrides?: CallOverrides): Promise<BigNumber>;
+    transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    unpause(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    xHAFeesDeposit(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    xHAFeesWithdraw(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    xKeeperFeesClosing(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    yHAFeesDeposit(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    yHAFeesWithdraw(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    yKeeperFeesClosing(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    callStatic: {
+        admin(overrides?: CallOverrides): Promise<string>;
+        changeAdmin(newAdmin: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        implementation(overrides?: CallOverrides): Promise<string>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+        BASE_PARAMS(overrides?: CallOverrides): Promise<BigNumber>;
+        BASE_TOKENS(overrides?: CallOverrides): Promise<BigNumber>;
+        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
+        GUARDIAN_ROLE(overrides?: CallOverrides): Promise<string>;
+        POOLMANAGER_ROLE(overrides?: CallOverrides): Promise<string>;
+        addToPerpetual(perpetualID: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        approve(to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        balanceOf(owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        baseURI(overrides?: CallOverrides): Promise<string>;
+        closePerpetual(perpetualID: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, minCashOutAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        deployCollateral(governorList: PromiseOrValue<string>[], guardian: PromiseOrValue<string>, feeManager_: PromiseOrValue<string>, oracle_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        earned(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        forceClosePerpetuals(perpetualIDs: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
+        getApproved(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        getCashOutAmount(perpetualID: PromiseOrValue<BigNumberish>, rate: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>;
+        getReward(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        getRoleAdmin(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+        grantRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        haBonusMalusDeposit(overrides?: CallOverrides): Promise<BigNumber>;
+        haBonusMalusWithdraw(overrides?: CallOverrides): Promise<BigNumber>;
+        hasRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        initialize(poolManager_: PromiseOrValue<string>, rewardToken_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        isApprovedForAll(owner: PromiseOrValue<string>, operator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        isApprovedOrOwner(spender: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+        keeperFeesClosingCap(overrides?: CallOverrides): Promise<BigNumber>;
+        keeperFeesLiquidationCap(overrides?: CallOverrides): Promise<BigNumber>;
+        keeperFeesLiquidationRatio(overrides?: CallOverrides): Promise<BigNumber>;
+        lastUpdateTime(overrides?: CallOverrides): Promise<BigNumber>;
+        limitHAHedge(overrides?: CallOverrides): Promise<BigNumber>;
+        liquidatePerpetuals(perpetualIDs: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
+        lockTime(overrides?: CallOverrides): Promise<BigNumber>;
+        maintenanceMargin(overrides?: CallOverrides): Promise<BigNumber>;
+        maxLeverage(overrides?: CallOverrides): Promise<BigNumber>;
+        name(overrides?: CallOverrides): Promise<string>;
+        notifyRewardAmount(reward: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        openPerpetual(owner: PromiseOrValue<string>, margin: PromiseOrValue<BigNumberish>, committedAmount: PromiseOrValue<BigNumberish>, maxOracleRate: PromiseOrValue<BigNumberish>, minNetMargin: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        oracle(overrides?: CallOverrides): Promise<string>;
+        ownerOf(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        pause(overrides?: CallOverrides): Promise<void>;
+        paused(overrides?: CallOverrides): Promise<boolean>;
+        periodFinish(overrides?: CallOverrides): Promise<BigNumber>;
+        perpetualData(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            entryRate: BigNumber;
+            entryTimestamp: BigNumber;
+            margin: BigNumber;
+            committedAmount: BigNumber;
+        }>;
+        perpetualRewardPerTokenPaid(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        poolManager(overrides?: CallOverrides): Promise<string>;
+        recoverERC20(tokenAddress: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        removeFromPerpetual(perpetualID: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        renounceRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        revokeRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        rewardPerTokenStored(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardRate(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardToken(overrides?: CallOverrides): Promise<string>;
+        rewards(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        rewardsDistribution(overrides?: CallOverrides): Promise<string>;
+        rewardsDuration(overrides?: CallOverrides): Promise<BigNumber>;
+        "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, _data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+        setApprovalForAll(operator: PromiseOrValue<string>, approved: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
+        setBaseURI(_baseURI: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setBoundsPerpetual(_maxLeverage: PromiseOrValue<BigNumberish>, _maintenanceMargin: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        setFeeKeeper(feeDeposit: PromiseOrValue<BigNumberish>, feeWithdraw: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        setFeeManager(feeManager_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setHAFees(_xHAFees: PromiseOrValue<BigNumberish>[], _yHAFees: PromiseOrValue<BigNumberish>[], deposit: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        setKeeperFeesCap(_keeperFeesLiquidationCap: PromiseOrValue<BigNumberish>, _keeperFeesClosingCap: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        setKeeperFeesClosing(_xKeeperFeesClosing: PromiseOrValue<BigNumberish>[], _yKeeperFeesClosing: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
+        setKeeperFeesLiquidationRatio(_keeperFeesLiquidationRatio: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        setLockTime(_lockTime: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        setNewRewardsDistribution(_rewardsDistribution: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setOracle(oracle_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setRewardDistribution(_rewardsDuration: PromiseOrValue<BigNumberish>, _rewardsDistribution: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setTargetAndLimitHAHedge(_targetHAHedge: PromiseOrValue<BigNumberish>, _limitHAHedge: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        symbol(overrides?: CallOverrides): Promise<string>;
+        targetHAHedge(overrides?: CallOverrides): Promise<BigNumber>;
+        tokenURI(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        totalHedgeAmount(overrides?: CallOverrides): Promise<BigNumber>;
+        transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        unpause(overrides?: CallOverrides): Promise<void>;
+        xHAFeesDeposit(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        xHAFeesWithdraw(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        xKeeperFeesClosing(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        yHAFeesDeposit(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        yHAFeesWithdraw(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        yKeeperFeesClosing(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    filters: {
+        "AdminChanged(address,address)"(previousAdmin?: null, newAdmin?: null): AdminChangedEventFilter;
+        AdminChanged(previousAdmin?: null, newAdmin?: null): AdminChangedEventFilter;
+        "BeaconUpgraded(address)"(beacon?: PromiseOrValue<string> | null): BeaconUpgradedEventFilter;
+        BeaconUpgraded(beacon?: PromiseOrValue<string> | null): BeaconUpgradedEventFilter;
+        "Upgraded(address)"(implementation?: PromiseOrValue<string> | null): UpgradedEventFilter;
+        Upgraded(implementation?: PromiseOrValue<string> | null): UpgradedEventFilter;
+        "Approval(address,address,uint256)"(owner?: PromiseOrValue<string> | null, approved?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null): ApprovalEventFilter;
+        Approval(owner?: PromiseOrValue<string> | null, approved?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null): ApprovalEventFilter;
+        "ApprovalForAll(address,address,bool)"(owner?: PromiseOrValue<string> | null, operator?: PromiseOrValue<string> | null, approved?: null): ApprovalForAllEventFilter;
+        ApprovalForAll(owner?: PromiseOrValue<string> | null, operator?: PromiseOrValue<string> | null, approved?: null): ApprovalForAllEventFilter;
+        "BaseURIUpdated(string)"(_baseURI?: null): BaseURIUpdatedEventFilter;
+        BaseURIUpdated(_baseURI?: null): BaseURIUpdatedEventFilter;
+        "BoundsPerpetualUpdated(uint64,uint64)"(_maxLeverage?: null, _maintenanceMargin?: null): BoundsPerpetualUpdatedEventFilter;
+        BoundsPerpetualUpdated(_maxLeverage?: null, _maintenanceMargin?: null): BoundsPerpetualUpdatedEventFilter;
+        "HAFeesUpdated(uint64[],uint64[],uint8)"(_xHAFees?: null, _yHAFees?: null, deposit?: null): HAFeesUpdatedEventFilter;
+        HAFeesUpdated(_xHAFees?: null, _yHAFees?: null, deposit?: null): HAFeesUpdatedEventFilter;
+        "KeeperFeesCapUpdated(uint256,uint256)"(_keeperFeesLiquidationCap?: null, _keeperFeesClosingCap?: null): KeeperFeesCapUpdatedEventFilter;
+        KeeperFeesCapUpdated(_keeperFeesLiquidationCap?: null, _keeperFeesClosingCap?: null): KeeperFeesCapUpdatedEventFilter;
+        "KeeperFeesClosingUpdated(uint64[],uint64[])"(xKeeperFeesClosing?: null, yKeeperFeesClosing?: null): KeeperFeesClosingUpdatedEventFilter;
+        KeeperFeesClosingUpdated(xKeeperFeesClosing?: null, yKeeperFeesClosing?: null): KeeperFeesClosingUpdatedEventFilter;
+        "KeeperFeesLiquidationRatioUpdated(uint64)"(_keeperFeesLiquidationRatio?: null): KeeperFeesLiquidationRatioUpdatedEventFilter;
+        KeeperFeesLiquidationRatioUpdated(_keeperFeesLiquidationRatio?: null): KeeperFeesLiquidationRatioUpdatedEventFilter;
+        "KeeperTransferred(address,uint256)"(keeperAddress?: null, liquidationFees?: null): KeeperTransferredEventFilter;
+        KeeperTransferred(keeperAddress?: null, liquidationFees?: null): KeeperTransferredEventFilter;
+        "LockTimeUpdated(uint64)"(_lockTime?: null): LockTimeUpdatedEventFilter;
+        LockTimeUpdated(_lockTime?: null): LockTimeUpdatedEventFilter;
+        "Paused(address)"(account?: null): PausedEventFilter;
+        Paused(account?: null): PausedEventFilter;
+        "PerpetualClosed(uint256,uint256)"(_perpetualID?: null, _closeAmount?: null): PerpetualClosedEventFilter;
+        PerpetualClosed(_perpetualID?: null, _closeAmount?: null): PerpetualClosedEventFilter;
+        "PerpetualOpened(uint256,uint256,uint256,uint256)"(_perpetualID?: null, _entryRate?: null, _margin?: null, _committedAmount?: null): PerpetualOpenedEventFilter;
+        PerpetualOpened(_perpetualID?: null, _entryRate?: null, _margin?: null, _committedAmount?: null): PerpetualOpenedEventFilter;
+        "PerpetualUpdated(uint256,uint256)"(_perpetualID?: null, _margin?: null): PerpetualUpdatedEventFilter;
+        PerpetualUpdated(_perpetualID?: null, _margin?: null): PerpetualUpdatedEventFilter;
+        "PerpetualsForceClosed(uint256[],tuple[],address,uint256)"(perpetualIDs?: null, ownerAndCashOut?: null, keeper?: null, reward?: null): PerpetualsForceClosedEventFilter;
+        PerpetualsForceClosed(perpetualIDs?: null, ownerAndCashOut?: null, keeper?: null, reward?: null): PerpetualsForceClosedEventFilter;
+        "Recovered(address,address,uint256)"(tokenAddress?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, amount?: null): RecoveredEventFilter;
+        Recovered(tokenAddress?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, amount?: null): RecoveredEventFilter;
+        "RewardAdded(uint256)"(_reward?: null): RewardAddedEventFilter;
+        RewardAdded(_reward?: null): RewardAddedEventFilter;
+        "RewardPaid(address,uint256)"(_user?: PromiseOrValue<string> | null, _reward?: null): RewardPaidEventFilter;
+        RewardPaid(_user?: PromiseOrValue<string> | null, _reward?: null): RewardPaidEventFilter;
+        "RewardsDistributionDurationUpdated(uint256,address)"(_rewardsDuration?: null, _rewardsDistributor?: PromiseOrValue<string> | null): RewardsDistributionDurationUpdatedEventFilter;
+        RewardsDistributionDurationUpdated(_rewardsDuration?: null, _rewardsDistributor?: PromiseOrValue<string> | null): RewardsDistributionDurationUpdatedEventFilter;
+        "RewardsDistributionUpdated(address)"(_rewardsDistributor?: PromiseOrValue<string> | null): RewardsDistributionUpdatedEventFilter;
+        RewardsDistributionUpdated(_rewardsDistributor?: PromiseOrValue<string> | null): RewardsDistributionUpdatedEventFilter;
+        "RoleAdminChanged(bytes32,bytes32,bytes32)"(role?: PromiseOrValue<BytesLike> | null, previousAdminRole?: PromiseOrValue<BytesLike> | null, newAdminRole?: PromiseOrValue<BytesLike> | null): RoleAdminChangedEventFilter;
+        RoleAdminChanged(role?: PromiseOrValue<BytesLike> | null, previousAdminRole?: PromiseOrValue<BytesLike> | null, newAdminRole?: PromiseOrValue<BytesLike> | null): RoleAdminChangedEventFilter;
+        "RoleGranted(bytes32,address,address)"(role?: PromiseOrValue<BytesLike> | null, account?: PromiseOrValue<string> | null, sender?: PromiseOrValue<string> | null): RoleGrantedEventFilter;
+        RoleGranted(role?: PromiseOrValue<BytesLike> | null, account?: PromiseOrValue<string> | null, sender?: PromiseOrValue<string> | null): RoleGrantedEventFilter;
+        "RoleRevoked(bytes32,address,address)"(role?: PromiseOrValue<BytesLike> | null, account?: PromiseOrValue<string> | null, sender?: PromiseOrValue<string> | null): RoleRevokedEventFilter;
+        RoleRevoked(role?: PromiseOrValue<BytesLike> | null, account?: PromiseOrValue<string> | null, sender?: PromiseOrValue<string> | null): RoleRevokedEventFilter;
+        "TargetAndLimitHAHedgeUpdated(uint64,uint64)"(_targetHAHedge?: null, _limitHAHedge?: null): TargetAndLimitHAHedgeUpdatedEventFilter;
+        TargetAndLimitHAHedgeUpdated(_targetHAHedge?: null, _limitHAHedge?: null): TargetAndLimitHAHedgeUpdatedEventFilter;
+        "Transfer(address,address,uint256)"(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null): TransferEventFilter;
+        Transfer(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null): TransferEventFilter;
+        "Unpaused(address)"(account?: null): UnpausedEventFilter;
+        Unpaused(account?: null): UnpausedEventFilter;
+    };
+    estimateGas: {
+        admin(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        changeAdmin(newAdmin: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        implementation(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        BASE_PARAMS(overrides?: CallOverrides): Promise<BigNumber>;
+        BASE_TOKENS(overrides?: CallOverrides): Promise<BigNumber>;
+        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<BigNumber>;
+        GUARDIAN_ROLE(overrides?: CallOverrides): Promise<BigNumber>;
+        POOLMANAGER_ROLE(overrides?: CallOverrides): Promise<BigNumber>;
+        addToPerpetual(perpetualID: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        approve(to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        balanceOf(owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        baseURI(overrides?: CallOverrides): Promise<BigNumber>;
+        closePerpetual(perpetualID: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, minCashOutAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        deployCollateral(governorList: PromiseOrValue<string>[], guardian: PromiseOrValue<string>, feeManager_: PromiseOrValue<string>, oracle_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        earned(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        forceClosePerpetuals(perpetualIDs: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        getApproved(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        getCashOutAmount(perpetualID: PromiseOrValue<BigNumberish>, rate: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        getReward(perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        getRoleAdmin(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        grantRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        haBonusMalusDeposit(overrides?: CallOverrides): Promise<BigNumber>;
+        haBonusMalusWithdraw(overrides?: CallOverrides): Promise<BigNumber>;
+        hasRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        initialize(poolManager_: PromiseOrValue<string>, rewardToken_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        isApprovedForAll(owner: PromiseOrValue<string>, operator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        isApprovedOrOwner(spender: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        keeperFeesClosingCap(overrides?: CallOverrides): Promise<BigNumber>;
+        keeperFeesLiquidationCap(overrides?: CallOverrides): Promise<BigNumber>;
+        keeperFeesLiquidationRatio(overrides?: CallOverrides): Promise<BigNumber>;
+        lastUpdateTime(overrides?: CallOverrides): Promise<BigNumber>;
+        limitHAHedge(overrides?: CallOverrides): Promise<BigNumber>;
+        liquidatePerpetuals(perpetualIDs: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        lockTime(overrides?: CallOverrides): Promise<BigNumber>;
+        maintenanceMargin(overrides?: CallOverrides): Promise<BigNumber>;
+        maxLeverage(overrides?: CallOverrides): Promise<BigNumber>;
+        name(overrides?: CallOverrides): Promise<BigNumber>;
+        notifyRewardAmount(reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        openPerpetual(owner: PromiseOrValue<string>, margin: PromiseOrValue<BigNumberish>, committedAmount: PromiseOrValue<BigNumberish>, maxOracleRate: PromiseOrValue<BigNumberish>, minNetMargin: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        oracle(overrides?: CallOverrides): Promise<BigNumber>;
+        ownerOf(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        pause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        paused(overrides?: CallOverrides): Promise<BigNumber>;
+        periodFinish(overrides?: CallOverrides): Promise<BigNumber>;
+        perpetualData(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        perpetualRewardPerTokenPaid(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        poolManager(overrides?: CallOverrides): Promise<BigNumber>;
+        recoverERC20(tokenAddress: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        removeFromPerpetual(perpetualID: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        renounceRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        revokeRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        rewardPerTokenStored(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardRate(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardToken(overrides?: CallOverrides): Promise<BigNumber>;
+        rewards(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        rewardsDistribution(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardsDuration(overrides?: CallOverrides): Promise<BigNumber>;
+        "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, _data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setApprovalForAll(operator: PromiseOrValue<string>, approved: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setBaseURI(_baseURI: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setBoundsPerpetual(_maxLeverage: PromiseOrValue<BigNumberish>, _maintenanceMargin: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setFeeKeeper(feeDeposit: PromiseOrValue<BigNumberish>, feeWithdraw: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setFeeManager(feeManager_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setHAFees(_xHAFees: PromiseOrValue<BigNumberish>[], _yHAFees: PromiseOrValue<BigNumberish>[], deposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setKeeperFeesCap(_keeperFeesLiquidationCap: PromiseOrValue<BigNumberish>, _keeperFeesClosingCap: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setKeeperFeesClosing(_xKeeperFeesClosing: PromiseOrValue<BigNumberish>[], _yKeeperFeesClosing: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setKeeperFeesLiquidationRatio(_keeperFeesLiquidationRatio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setLockTime(_lockTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setNewRewardsDistribution(_rewardsDistribution: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setOracle(oracle_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setRewardDistribution(_rewardsDuration: PromiseOrValue<BigNumberish>, _rewardsDistribution: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setTargetAndLimitHAHedge(_targetHAHedge: PromiseOrValue<BigNumberish>, _limitHAHedge: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        symbol(overrides?: CallOverrides): Promise<BigNumber>;
+        targetHAHedge(overrides?: CallOverrides): Promise<BigNumber>;
+        tokenURI(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        totalHedgeAmount(overrides?: CallOverrides): Promise<BigNumber>;
+        transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        unpause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        xHAFeesDeposit(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        xHAFeesWithdraw(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        xKeeperFeesClosing(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        yHAFeesDeposit(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        yHAFeesWithdraw(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        yKeeperFeesClosing(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        admin(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        changeAdmin(newAdmin: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        implementation(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        BASE_PARAMS(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        BASE_TOKENS(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        GUARDIAN_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        POOLMANAGER_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        addToPerpetual(perpetualID: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        approve(to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        balanceOf(owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        baseURI(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        closePerpetual(perpetualID: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, minCashOutAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        deployCollateral(governorList: PromiseOrValue<string>[], guardian: PromiseOrValue<string>, feeManager_: PromiseOrValue<string>, oracle_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        earned(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        forceClosePerpetuals(perpetualIDs: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        getApproved(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getCashOutAmount(perpetualID: PromiseOrValue<BigNumberish>, rate: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getReward(perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        getRoleAdmin(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        grantRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        haBonusMalusDeposit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        haBonusMalusWithdraw(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        hasRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        initialize(poolManager_: PromiseOrValue<string>, rewardToken_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        isApprovedForAll(owner: PromiseOrValue<string>, operator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isApprovedOrOwner(spender: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        keeperFeesClosingCap(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        keeperFeesLiquidationCap(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        keeperFeesLiquidationRatio(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        lastUpdateTime(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        limitHAHedge(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        liquidatePerpetuals(perpetualIDs: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        lockTime(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        maintenanceMargin(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        maxLeverage(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        notifyRewardAmount(reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        openPerpetual(owner: PromiseOrValue<string>, margin: PromiseOrValue<BigNumberish>, committedAmount: PromiseOrValue<BigNumberish>, maxOracleRate: PromiseOrValue<BigNumberish>, minNetMargin: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        oracle(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        ownerOf(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        paused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        periodFinish(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        perpetualData(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        perpetualRewardPerTokenPaid(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        poolManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        recoverERC20(tokenAddress: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        removeFromPerpetual(perpetualID: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        renounceRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        revokeRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        rewardPerTokenStored(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewardRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewardToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewards(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewardsDistribution(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewardsDuration(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, _data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setApprovalForAll(operator: PromiseOrValue<string>, approved: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setBaseURI(_baseURI: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setBoundsPerpetual(_maxLeverage: PromiseOrValue<BigNumberish>, _maintenanceMargin: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setFeeKeeper(feeDeposit: PromiseOrValue<BigNumberish>, feeWithdraw: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setFeeManager(feeManager_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setHAFees(_xHAFees: PromiseOrValue<BigNumberish>[], _yHAFees: PromiseOrValue<BigNumberish>[], deposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setKeeperFeesCap(_keeperFeesLiquidationCap: PromiseOrValue<BigNumberish>, _keeperFeesClosingCap: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setKeeperFeesClosing(_xKeeperFeesClosing: PromiseOrValue<BigNumberish>[], _yKeeperFeesClosing: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setKeeperFeesLiquidationRatio(_keeperFeesLiquidationRatio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setLockTime(_lockTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setNewRewardsDistribution(_rewardsDistribution: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setOracle(oracle_: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setRewardDistribution(_rewardsDuration: PromiseOrValue<BigNumberish>, _rewardsDistribution: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setTargetAndLimitHAHedge(_targetHAHedge: PromiseOrValue<BigNumberish>, _limitHAHedge: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        targetHAHedge(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        tokenURI(perpetualID: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalHedgeAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, perpetualID: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        unpause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        xHAFeesDeposit(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        xHAFeesWithdraw(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        xKeeperFeesClosing(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        yHAFeesDeposit(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        yHAFeesWithdraw(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        yKeeperFeesClosing(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}