@pendle/core-v2 2.23.1-mantle → 2.23.2-mantle

package/contracts/offchain-helpers/errors/SDKErrorsDirectory.sol

@@ -0,0 +1,149 @@
+pragma solidity 0.8.17;
+
+library SDKErrorsDirectory {
+    error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error BulkNotMaintainer();
+    error BulkNotAdmin();
+    error BulkSellerAlreadyExisted(address token, address SY, address bulk);
+    error BulkSellerInvalidToken(address token, address SY);
+    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error ApproxFail();
+    error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
+    error ApproxBinarySearchInputInvalid(
+        uint256 approxGuessMin,
+        uint256 approxGuessMax,
+        uint256 minGuessMin,
+        uint256 maxGuessMax
+    );
+    error MarketExpired();
+    error MarketZeroAmountsInput();
+    error MarketZeroAmountsOutput();
+    error MarketZeroLnImpliedRate();
+    error MarketInsufficientPtForTrade(int256 currentAmount, int256 requiredAmount);
+    error MarketInsufficientPtReceived(uint256 actualBalance, uint256 requiredBalance);
+    error MarketInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error MarketZeroTotalPtOrTotalAsset(int256 totalPt, int256 totalAsset);
+    error MarketExchangeRateBelowOne(int256 exchangeRate);
+    error MarketProportionMustNotEqualOne();
+    error MarketRateScalarBelowZero(int256 rateScalar);
+    error MarketScalarRootBelowZero(int256 scalarRoot);
+    error MarketProportionTooHigh(int256 proportion, int256 maxProportion);
+    error OracleUninitialized();
+    error OracleTargetTooOld(uint32 target, uint32 oldest);
+    error OracleZeroCardinality();
+    error MarketFactoryExpiredPt();
+    error MarketFactoryInvalidPt();
+    error MarketFactoryMarketExists();
+    error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
+    error MarketFactoryReserveFeePercentTooHigh(
+        uint8 reserveFeePercent,
+        uint8 maxReserveFeePercent
+    );
+    error MarketFactoryZeroTreasury();
+    error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
+    error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
+    error RouterInsufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error RouterInsufficientPtOut(uint256 actualPtOut, uint256 requiredPtOut);
+    error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
+    error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
+    error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error RouterExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
+    error RouterExceededLimitPtIn(uint256 actualPtIn, uint256 limitPtIn);
+    error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
+    error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
+    error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
+    error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
+    error RouterTimeRangeZero();
+    error RouterCallbackNotPendleMarket(address caller);
+    error RouterInvalidAction(bytes4 selector);
+    error RouterInvalidFacet(address facet);
+    error RouterKyberSwapDataZero();
+    error YCExpired();
+    error YCNotExpired();
+    error YieldContractInsufficientSy(uint256 actualSy, uint256 requiredSy);
+    error YCNothingToRedeem();
+    error YCPostExpiryDataNotSet();
+    error YCNoFloatingSy();
+    error YCFactoryInvalidExpiry();
+    error YCFactoryYieldContractExisted();
+    error YCFactoryZeroExpiryDivisor();
+    error YCFactoryZeroTreasury();
+    error YCFactoryInterestFeeRateTooHigh(uint256 interestFeeRate, uint256 maxInterestFeeRate);
+    error YCFactoryRewardFeeRateTooHigh(uint256 newRewardFeeRate, uint256 maxRewardFeeRate);
+    error SYInvalidTokenIn(address token);
+    error SYInvalidTokenOut(address token);
+    error SYZeroDeposit();
+    error SYZeroRedeem();
+    error SYInsufficientSharesOut(uint256 actualSharesOut, uint256 requiredSharesOut);
+    error SYInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error SYQiTokenMintFailed(uint256 errCode);
+    error SYQiTokenRedeemFailed(uint256 errCode);
+    error SYQiTokenRedeemRewardsFailed(uint256 rewardAccruedType0, uint256 rewardAccruedType1);
+    error SYQiTokenBorrowRateTooHigh(uint256 borrowRate, uint256 borrowRateMax);
+    error SYCurveInvalidPid();
+    error SYCurve3crvPoolNotFound();
+    error SYApeDepositAmountTooSmall(uint256 amountDeposited);
+    error SYBalancerInvalidPid();
+    error SYInvalidRewardToken(address token);
+    error SYStargateRedeemCapExceeded(uint256 amountLpDesired, uint256 amountLpRedeemable);
+    error SYBalancerReentrancy();
+    error NotFromTrustedRemote(uint16 srcChainId, bytes path);
+    error VCInactivePool(address pool);
+    error VCPoolAlreadyActive(address pool);
+    error VCZeroVePendle(address user);
+    error VCExceededMaxWeight(uint256 totalWeight, uint256 maxWeight);
+    error VCEpochNotFinalized(uint256 wTime);
+    error VCPoolAlreadyAddAndRemoved(address pool);
+    error VEInvalidNewExpiry(uint256 newExpiry);
+    error VEExceededMaxLockTime();
+    error VEInsufficientLockTime();
+    error VENotAllowedReduceExpiry();
+    error VEZeroAmountLocked();
+    error VEPositionNotExpired();
+    error VEZeroPosition();
+    error VEZeroSlope(uint128 bias, uint128 slope);
+    error VEReceiveOldSupply(uint256 msgTime);
+    error GCNotPendleMarket(address caller);
+    error GCNotVotingController(address caller);
+    error InvalidWTime(uint256 wTime);
+    error ExpiryInThePast(uint256 expiry);
+    error ChainNotSupported(uint256 chainId);
+    error FDTotalAmountFundedNotMatch(uint256 actualTotalAmount, uint256 expectedTotalAmount);
+    error FDEpochLengthMismatch();
+    error FDInvalidPool(address pool);
+    error FDPoolAlreadyExists(address pool);
+    error FDInvalidNewFinishedEpoch(uint256 oldFinishedEpoch, uint256 newFinishedEpoch);
+    error FDInvalidStartEpoch(uint256 startEpoch);
+    error FDInvalidWTimeFund(uint256 lastFunded, uint256 wTime);
+    error FDFutureFunding(uint256 lastFunded, uint256 currentWTime);
+    error BDInvalidEpoch(uint256 epoch, uint256 startTime);
+    error MsgNotFromSendEndpoint(uint16 srcChainId, bytes path);
+    error MsgNotFromReceiveEndpoint(address sender);
+    error InsufficientFeeToSendMsg(uint256 currentFee, uint256 requiredFee);
+    error ApproxDstExecutionGasNotSet();
+    error InvalidRetryData();
+    error ArrayLengthMismatch();
+    error ArrayEmpty();
+    error ArrayOutOfBounds();
+    error ZeroAddress();
+    error FailedToSendEther();
+    error InvalidMerkleProof();
+    error OnlyLayerZeroEndpoint();
+    error OnlyYT();
+    error OnlyYCFactory();
+    error OnlyWhitelisted();
+    error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
+    error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
+    error MinimumStakeAmountNotReached(uint256 amountToStake, uint256 minimumStakeAmount);
+    error MinimumRedeemAmountNotReached(uint256 amountToRedeem, uint256 minimumRedeemAmount);
+    error UnstakeCapacityTooLow(uint256 amountBondToRedeem, uint256 unstakeCapacity);
+    error InvalidTokenId(uint256 tokenId, uint256 positionId);
+    error InvalidBlockRate(uint256 blockCycleNumerator);
+    error TwapDurationTooLarge(uint32 duration, uint32 cardinalityRequired);
+    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
+}

package/deployments/5000-markets/WSTETH-MANTLE-MARCH2024.json

@@ -3,7 +3,7 @@
     "SY": "0xeC030Ca1A8bc0084271d5CC3E0bd3184B1DDFC27",
     "YT": "0x6B212804b510c1140d8a968888F0B3b8b2FB71E0",
     "PT": "0xbFDc43Fd918586673f308D898f10e9B87dc8dB5B",
-    "market": "0xf6936e20859fc2085544852c65787f8870AE8dFa",
+    "market": "0x3ae145cc22cd07a8de7eae7d83fb5b6b2363673a",
     "expiry": 1711584000,
     "scalarRoot": "197848855033000000000",
     "initAnchor": "1025391787000000000"

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.23.1-mantle",
+  "version": "2.23.2-mantle",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/AllErrorsDirectory.ts

@@ -0,0 +1,57 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { BaseContract, Signer, utils } from "ethers";
+
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface AllErrorsDirectoryInterface extends utils.Interface {
+  contractName: "AllErrorsDirectory";
+  functions: {};
+
+  events: {};
+}
+
+export interface AllErrorsDirectory extends BaseContract {
+  contractName: "AllErrorsDirectory";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: AllErrorsDirectoryInterface;
+
+  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: {};
+
+  callStatic: {};
+
+  filters: {};
+
+  estimateGas: {};
+
+  populateTransaction: {};
+}

package/typechain-types/ComposableStablePreview.ts

@@ -7,14 +7,11 @@ import {
   BigNumberish,
   BytesLike,
   CallOverrides,
-  ContractTransaction,
-  Overrides,
-  PayableOverrides,
   PopulatedTransaction,
   Signer,
   utils,
 } from "ethers";
-import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import { FunctionFragment, Result } from "@ethersproject/abi";
 import { Listener, Provider } from "@ethersproject/providers";
 import type {
   TypedEventFilter,
@@ -66,127 +63,31 @@ export declare namespace IVault {
 export interface ComposableStablePreviewInterface extends utils.Interface {
   contractName: "ComposableStablePreview";
   functions: {
-    "claimOwnership()": FunctionFragment;
     "exitPoolPreview(bytes32,address,address,(address[],uint256[],bytes,bool),bytes)": FunctionFragment;
-    "initialize()": FunctionFragment;
     "joinPoolPreview(bytes32,address,address,(address[],uint256[],bytes,bool),bytes)": FunctionFragment;
-    "owner()": FunctionFragment;
-    "pendingOwner()": FunctionFragment;
-    "proxiableUUID()": FunctionFragment;
-    "transferOwnership(address,bool,bool)": FunctionFragment;
-    "upgradeTo(address)": FunctionFragment;
-    "upgradeToAndCall(address,bytes)": FunctionFragment;
   };
 
-  encodeFunctionData(
-    functionFragment: "claimOwnership",
-    values?: undefined
-  ): string;
   encodeFunctionData(
     functionFragment: "exitPoolPreview",
     values: [BytesLike, string, string, IVault.ExitPoolRequestStruct, BytesLike]
   ): string;
-  encodeFunctionData(
-    functionFragment: "initialize",
-    values?: undefined
-  ): string;
   encodeFunctionData(
     functionFragment: "joinPoolPreview",
     values: [BytesLike, string, string, IVault.JoinPoolRequestStruct, BytesLike]
   ): string;
-  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
-  encodeFunctionData(
-    functionFragment: "pendingOwner",
-    values?: undefined
-  ): string;
-  encodeFunctionData(
-    functionFragment: "proxiableUUID",
-    values?: undefined
-  ): string;
-  encodeFunctionData(
-    functionFragment: "transferOwnership",
-    values: [string, boolean, boolean]
-  ): string;
-  encodeFunctionData(functionFragment: "upgradeTo", values: [string]): string;
-  encodeFunctionData(
-    functionFragment: "upgradeToAndCall",
-    values: [string, BytesLike]
-  ): string;
 
-  decodeFunctionResult(
-    functionFragment: "claimOwnership",
-    data: BytesLike
-  ): Result;
   decodeFunctionResult(
     functionFragment: "exitPoolPreview",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "joinPoolPreview",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
-  decodeFunctionResult(
-    functionFragment: "pendingOwner",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "proxiableUUID",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(
-    functionFragment: "transferOwnership",
-    data: BytesLike
-  ): Result;
-  decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
-  decodeFunctionResult(
-    functionFragment: "upgradeToAndCall",
-    data: BytesLike
-  ): Result;
-
-  events: {
-    "AdminChanged(address,address)": EventFragment;
-    "BeaconUpgraded(address)": EventFragment;
-    "Initialized(uint8)": EventFragment;
-    "OwnershipTransferred(address,address)": EventFragment;
-    "Upgraded(address)": EventFragment;
-  };
 
-  getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
+  events: {};
 }
 
-export type AdminChangedEvent = TypedEvent<
-  [string, string],
-  { previousAdmin: string; newAdmin: string }
->;
-
-export type AdminChangedEventFilter = TypedEventFilter<AdminChangedEvent>;
-
-export type BeaconUpgradedEvent = TypedEvent<[string], { beacon: string }>;
-
-export type BeaconUpgradedEventFilter = TypedEventFilter<BeaconUpgradedEvent>;
-
-export type InitializedEvent = TypedEvent<[number], { version: number }>;
-
-export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
-
-export type OwnershipTransferredEvent = TypedEvent<
-  [string, string],
-  { previousOwner: string; newOwner: string }
->;
-
-export type OwnershipTransferredEventFilter =
-  TypedEventFilter<OwnershipTransferredEvent>;
-
-export type UpgradedEvent = TypedEvent<[string], { implementation: string }>;
-
-export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
-
 export interface ComposableStablePreview extends BaseContract {
   contractName: "ComposableStablePreview";
   connect(signerOrProvider: Signer | Provider | string): this;
@@ -215,10 +116,6 @@ export interface ComposableStablePreview extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    claimOwnership(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
     exitPoolPreview(
       poolId: BytesLike,
       sender: string,
@@ -228,10 +125,6 @@ export interface ComposableStablePreview extends BaseContract {
       overrides?: CallOverrides
     ): Promise<[BigNumber] & { amountTokenOut: BigNumber }>;
 
-    initialize(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
     joinPoolPreview(
       poolId: BytesLike,
       sender: string,
@@ -240,36 +133,8 @@ export interface ComposableStablePreview extends BaseContract {
       data: BytesLike,
       overrides?: CallOverrides
     ): Promise<[BigNumber] & { amountBptOut: BigNumber }>;
-
-    owner(overrides?: CallOverrides): Promise<[string]>;
-
-    pendingOwner(overrides?: CallOverrides): Promise<[string]>;
-
-    proxiableUUID(overrides?: CallOverrides): Promise<[string]>;
-
-    transferOwnership(
-      newOwner: string,
-      direct: boolean,
-      renounce: boolean,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
-    upgradeTo(
-      newImplementation: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
-    upgradeToAndCall(
-      newImplementation: string,
-      data: BytesLike,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
   };
 
-  claimOwnership(
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
   exitPoolPreview(
     poolId: BytesLike,
     sender: string,
@@ -279,10 +144,6 @@ export interface ComposableStablePreview extends BaseContract {
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
-  initialize(
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
   joinPoolPreview(
     poolId: BytesLike,
     sender: string,
@@ -292,33 +153,7 @@ export interface ComposableStablePreview extends BaseContract {
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
-  owner(overrides?: CallOverrides): Promise<string>;
-
-  pendingOwner(overrides?: CallOverrides): Promise<string>;
-
-  proxiableUUID(overrides?: CallOverrides): Promise<string>;
-
-  transferOwnership(
-    newOwner: string,
-    direct: boolean,
-    renounce: boolean,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
-  upgradeTo(
-    newImplementation: string,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
-  upgradeToAndCall(
-    newImplementation: string,
-    data: BytesLike,
-    overrides?: PayableOverrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
   callStatic: {
-    claimOwnership(overrides?: CallOverrides): Promise<void>;
-
     exitPoolPreview(
       poolId: BytesLike,
       sender: string,
@@ -328,8 +163,6 @@ export interface ComposableStablePreview extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    initialize(overrides?: CallOverrides): Promise<void>;
-
     joinPoolPreview(
       poolId: BytesLike,
       sender: string,
@@ -338,68 +171,11 @@ export interface ComposableStablePreview extends BaseContract {
       data: BytesLike,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
-
-    owner(overrides?: CallOverrides): Promise<string>;
-
-    pendingOwner(overrides?: CallOverrides): Promise<string>;
-
-    proxiableUUID(overrides?: CallOverrides): Promise<string>;
-
-    transferOwnership(
-      newOwner: string,
-      direct: boolean,
-      renounce: boolean,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    upgradeTo(
-      newImplementation: string,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    upgradeToAndCall(
-      newImplementation: string,
-      data: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<void>;
   };
 
-  filters: {
-    "AdminChanged(address,address)"(
-      previousAdmin?: null,
-      newAdmin?: null
-    ): AdminChangedEventFilter;
-    AdminChanged(
-      previousAdmin?: null,
-      newAdmin?: null
-    ): AdminChangedEventFilter;
-
-    "BeaconUpgraded(address)"(
-      beacon?: string | null
-    ): BeaconUpgradedEventFilter;
-    BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter;
-
-    "Initialized(uint8)"(version?: null): InitializedEventFilter;
-    Initialized(version?: null): InitializedEventFilter;
-
-    "OwnershipTransferred(address,address)"(
-      previousOwner?: string | null,
-      newOwner?: string | null
-    ): OwnershipTransferredEventFilter;
-    OwnershipTransferred(
-      previousOwner?: string | null,
-      newOwner?: string | null
-    ): OwnershipTransferredEventFilter;
-
-    "Upgraded(address)"(implementation?: string | null): UpgradedEventFilter;
-    Upgraded(implementation?: string | null): UpgradedEventFilter;
-  };
+  filters: {};
 
   estimateGas: {
-    claimOwnership(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
-
     exitPoolPreview(
       poolId: BytesLike,
       sender: string,
@@ -409,10 +185,6 @@ export interface ComposableStablePreview extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    initialize(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
-
     joinPoolPreview(
       poolId: BytesLike,
       sender: string,
@@ -421,37 +193,9 @@ export interface ComposableStablePreview extends BaseContract {
       data: BytesLike,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
-
-    owner(overrides?: CallOverrides): Promise<BigNumber>;
-
-    pendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
-
-    proxiableUUID(overrides?: CallOverrides): Promise<BigNumber>;
-
-    transferOwnership(
-      newOwner: string,
-      direct: boolean,
-      renounce: boolean,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
-
-    upgradeTo(
-      newImplementation: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
-
-    upgradeToAndCall(
-      newImplementation: string,
-      data: BytesLike,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    claimOwnership(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
-
     exitPoolPreview(
       poolId: BytesLike,
       sender: string,
@@ -461,10 +205,6 @@ export interface ComposableStablePreview extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    initialize(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
-
     joinPoolPreview(
       poolId: BytesLike,
       sender: string,
@@ -473,29 +213,5 @@ export interface ComposableStablePreview extends BaseContract {
       data: BytesLike,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
-
-    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    pendingOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    proxiableUUID(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    transferOwnership(
-      newOwner: string,
-      direct: boolean,
-      renounce: boolean,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
-
-    upgradeTo(
-      newImplementation: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
-
-    upgradeToAndCall(
-      newImplementation: string,
-      data: BytesLike,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
   };
 }