@huma-finance/shared 0.0.48-beta.279 → 0.0.48-beta.280

package/dist/cjs/v2/abis/PoolSafe.json

@@ -1,23 +1,50 @@
 [
     {
         "inputs": [],
-        "name": "notAuthorizedCaller",
+        "name": "AuthorizedContractCallerRequired",
         "type": "error"
     },
     {
         "inputs": [],
-        "name": "notPool",
+        "name": "TrancheRequired",
         "type": "error"
     },
     {
         "inputs": [],
-        "name": "todo",
+        "name": "ZeroAddressProvided",
         "type": "error"
     },
     {
-        "inputs": [],
-        "name": "zeroAddressProvided",
-        "type": "error"
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "previousAdmin",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "newAdmin",
+                "type": "address"
+            }
+        ],
+        "name": "AdminChanged",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "beacon",
+                "type": "address"
+            }
+        ],
+        "name": "BeaconUpgraded",
+        "type": "event"
     },
     {
         "anonymous": false,
@@ -64,6 +91,19 @@
         "name": "PoolConfigChanged",
         "type": "event"
     },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "implementation",
+                "type": "address"
+            }
+        ],
+        "name": "Upgraded",
+        "type": "event"
+    },
     {
         "inputs": [
             {
@@ -102,11 +142,11 @@
     },
     {
         "inputs": [],
-        "name": "getAvailableLiquidityForFees",
+        "name": "getAvailableBalanceForFees",
         "outputs": [
             {
                 "internalType": "uint256",
-                "name": "liquidity",
+                "name": "availableBalance",
                 "type": "uint256"
             }
         ],
@@ -115,11 +155,11 @@
     },
     {
         "inputs": [],
-        "name": "getPoolLiquidity",
+        "name": "getAvailableBalanceForPool",
         "outputs": [
             {
                 "internalType": "uint256",
-                "name": "liquidity",
+                "name": "availableBalance",
                 "type": "uint256"
             }
         ],
@@ -178,6 +218,19 @@
         "stateMutability": "view",
         "type": "function"
     },
+    {
+        "inputs": [],
+        "name": "proxiableUUID",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
     {
         "inputs": [],
         "name": "resetUnprocessedProfit",
@@ -200,7 +253,7 @@
     },
     {
         "inputs": [],
-        "name": "totalLiquidity",
+        "name": "totalBalance",
         "outputs": [
             {
                 "internalType": "uint256",
@@ -250,6 +303,37 @@
         "stateMutability": "nonpayable",
         "type": "function"
     },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "newImplementation",
+                "type": "address"
+            }
+        ],
+        "name": "upgradeTo",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "newImplementation",
+                "type": "address"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            }
+        ],
+        "name": "upgradeToAndCall",
+        "outputs": [],
+        "stateMutability": "payable",
+        "type": "function"
+    },
     {
         "inputs": [
             {

package/dist/cjs/v2/abis/types/PoolSafe.d.ts

@@ -1,4 +1,4 @@
-import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from 'ethers';
+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';
@@ -6,60 +6,91 @@ export interface PoolSafeInterface extends utils.Interface {
     functions: {
         'addUnprocessedProfit(address,uint256)': FunctionFragment;
         'deposit(address,uint256)': FunctionFragment;
-        'getAvailableLiquidityForFees()': FunctionFragment;
-        'getPoolLiquidity()': FunctionFragment;
+        'getAvailableBalanceForFees()': FunctionFragment;
+        'getAvailableBalanceForPool()': FunctionFragment;
         'initialize(address)': FunctionFragment;
         'pool()': FunctionFragment;
         'poolConfig()': FunctionFragment;
         'poolFeeManager()': FunctionFragment;
+        'proxiableUUID()': FunctionFragment;
         'resetUnprocessedProfit()': FunctionFragment;
         'setPoolConfig(address)': FunctionFragment;
-        'totalLiquidity()': FunctionFragment;
+        'totalBalance()': FunctionFragment;
         'underlyingToken()': FunctionFragment;
         'unprocessedTrancheProfit(address)': FunctionFragment;
         'updatePoolConfigData()': FunctionFragment;
+        'upgradeTo(address)': FunctionFragment;
+        'upgradeToAndCall(address,bytes)': FunctionFragment;
         'withdraw(address,uint256)': FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: 'addUnprocessedProfit' | 'deposit' | 'getAvailableLiquidityForFees' | 'getPoolLiquidity' | 'initialize' | 'pool' | 'poolConfig' | 'poolFeeManager' | 'resetUnprocessedProfit' | 'setPoolConfig' | 'totalLiquidity' | 'underlyingToken' | 'unprocessedTrancheProfit' | 'updatePoolConfigData' | 'withdraw'): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: 'addUnprocessedProfit' | 'deposit' | 'getAvailableBalanceForFees' | 'getAvailableBalanceForPool' | 'initialize' | 'pool' | 'poolConfig' | 'poolFeeManager' | 'proxiableUUID' | 'resetUnprocessedProfit' | 'setPoolConfig' | 'totalBalance' | 'underlyingToken' | 'unprocessedTrancheProfit' | 'updatePoolConfigData' | 'upgradeTo' | 'upgradeToAndCall' | 'withdraw'): FunctionFragment;
     encodeFunctionData(functionFragment: 'addUnprocessedProfit', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
     encodeFunctionData(functionFragment: 'deposit', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
-    encodeFunctionData(functionFragment: 'getAvailableLiquidityForFees', values?: undefined): string;
-    encodeFunctionData(functionFragment: 'getPoolLiquidity', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'getAvailableBalanceForFees', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'getAvailableBalanceForPool', values?: undefined): string;
     encodeFunctionData(functionFragment: 'initialize', values: [PromiseOrValue<string>]): string;
     encodeFunctionData(functionFragment: 'pool', values?: undefined): string;
     encodeFunctionData(functionFragment: 'poolConfig', values?: undefined): string;
     encodeFunctionData(functionFragment: 'poolFeeManager', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'proxiableUUID', values?: undefined): string;
     encodeFunctionData(functionFragment: 'resetUnprocessedProfit', values?: undefined): string;
     encodeFunctionData(functionFragment: 'setPoolConfig', values: [PromiseOrValue<string>]): string;
-    encodeFunctionData(functionFragment: 'totalLiquidity', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'totalBalance', values?: undefined): string;
     encodeFunctionData(functionFragment: 'underlyingToken', values?: undefined): string;
     encodeFunctionData(functionFragment: 'unprocessedTrancheProfit', values: [PromiseOrValue<string>]): string;
     encodeFunctionData(functionFragment: 'updatePoolConfigData', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'upgradeTo', values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: 'upgradeToAndCall', values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]): string;
     encodeFunctionData(functionFragment: 'withdraw', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
     decodeFunctionResult(functionFragment: 'addUnprocessedProfit', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'getAvailableLiquidityForFees', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'getPoolLiquidity', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getAvailableBalanceForFees', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getAvailableBalanceForPool', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'pool', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'poolConfig', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'poolFeeManager', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'proxiableUUID', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'resetUnprocessedProfit', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setPoolConfig', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'totalLiquidity', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'totalBalance', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'underlyingToken', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'unprocessedTrancheProfit', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'updatePoolConfigData', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'upgradeTo', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'upgradeToAndCall', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result;
     events: {
+        'AdminChanged(address,address)': EventFragment;
+        'BeaconUpgraded(address)': EventFragment;
         'Initialized(uint8)': EventFragment;
         'PoolConfigCacheUpdated(address)': EventFragment;
         'PoolConfigChanged(address,address)': EventFragment;
+        'Upgraded(address)': EventFragment;
     };
+    getEvent(nameOrSignatureOrTopic: 'AdminChanged'): EventFragment;
+    getEvent(nameOrSignatureOrTopic: 'BeaconUpgraded'): EventFragment;
     getEvent(nameOrSignatureOrTopic: 'Initialized'): EventFragment;
     getEvent(nameOrSignatureOrTopic: 'PoolConfigCacheUpdated'): EventFragment;
     getEvent(nameOrSignatureOrTopic: 'PoolConfigChanged'): EventFragment;
+    getEvent(nameOrSignatureOrTopic: 'Upgraded'): 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 InitializedEventObject {
     version: number;
 }
@@ -81,6 +112,11 @@ export type PoolConfigChangedEvent = TypedEvent<[
     string
 ], PoolConfigChangedEventObject>;
 export type PoolConfigChangedEventFilter = TypedEventFilter<PoolConfigChangedEvent>;
+export interface UpgradedEventObject {
+    implementation: string;
+}
+export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>;
+export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
 export interface PoolSafe extends BaseContract {
     connect(signerOrProvider: Signer | Provider | string): this;
     attach(addressOrName: string): this;
@@ -102,11 +138,11 @@ export interface PoolSafe extends BaseContract {
         deposit(from: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
-        getAvailableLiquidityForFees(overrides?: CallOverrides): Promise<[BigNumber] & {
-            liquidity: BigNumber;
+        getAvailableBalanceForFees(overrides?: CallOverrides): Promise<[BigNumber] & {
+            availableBalance: BigNumber;
         }>;
-        getPoolLiquidity(overrides?: CallOverrides): Promise<[BigNumber] & {
-            liquidity: BigNumber;
+        getAvailableBalanceForPool(overrides?: CallOverrides): Promise<[BigNumber] & {
+            availableBalance: BigNumber;
         }>;
         initialize(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
@@ -114,13 +150,14 @@ export interface PoolSafe extends BaseContract {
         pool(overrides?: CallOverrides): Promise<[string]>;
         poolConfig(overrides?: CallOverrides): Promise<[string]>;
         poolFeeManager(overrides?: CallOverrides): Promise<[string]>;
+        proxiableUUID(overrides?: CallOverrides): Promise<[string]>;
         resetUnprocessedProfit(overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
         setPoolConfig(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
-        totalLiquidity(overrides?: CallOverrides): Promise<[BigNumber] & {
+        totalBalance(overrides?: CallOverrides): Promise<[BigNumber] & {
             liquidity: BigNumber;
         }>;
         underlyingToken(overrides?: CallOverrides): Promise<[string]>;
@@ -128,6 +165,12 @@ export interface PoolSafe extends BaseContract {
         updatePoolConfigData(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>;
         withdraw(to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
@@ -138,53 +181,69 @@ export interface PoolSafe extends BaseContract {
     deposit(from: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
-    getAvailableLiquidityForFees(overrides?: CallOverrides): Promise<BigNumber>;
-    getPoolLiquidity(overrides?: CallOverrides): Promise<BigNumber>;
+    getAvailableBalanceForFees(overrides?: CallOverrides): Promise<BigNumber>;
+    getAvailableBalanceForPool(overrides?: CallOverrides): Promise<BigNumber>;
     initialize(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
     pool(overrides?: CallOverrides): Promise<string>;
     poolConfig(overrides?: CallOverrides): Promise<string>;
     poolFeeManager(overrides?: CallOverrides): Promise<string>;
+    proxiableUUID(overrides?: CallOverrides): Promise<string>;
     resetUnprocessedProfit(overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
     setPoolConfig(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
-    totalLiquidity(overrides?: CallOverrides): Promise<BigNumber>;
+    totalBalance(overrides?: CallOverrides): Promise<BigNumber>;
     underlyingToken(overrides?: CallOverrides): Promise<string>;
     unprocessedTrancheProfit(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
     updatePoolConfigData(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>;
     withdraw(to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
     callStatic: {
         addUnprocessedProfit(tranche: PromiseOrValue<string>, profit: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
         deposit(from: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
-        getAvailableLiquidityForFees(overrides?: CallOverrides): Promise<BigNumber>;
-        getPoolLiquidity(overrides?: CallOverrides): Promise<BigNumber>;
+        getAvailableBalanceForFees(overrides?: CallOverrides): Promise<BigNumber>;
+        getAvailableBalanceForPool(overrides?: CallOverrides): Promise<BigNumber>;
         initialize(_poolConfig: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
         pool(overrides?: CallOverrides): Promise<string>;
         poolConfig(overrides?: CallOverrides): Promise<string>;
         poolFeeManager(overrides?: CallOverrides): Promise<string>;
+        proxiableUUID(overrides?: CallOverrides): Promise<string>;
         resetUnprocessedProfit(overrides?: CallOverrides): Promise<void>;
         setPoolConfig(_poolConfig: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
-        totalLiquidity(overrides?: CallOverrides): Promise<BigNumber>;
+        totalBalance(overrides?: CallOverrides): Promise<BigNumber>;
         underlyingToken(overrides?: CallOverrides): Promise<string>;
         unprocessedTrancheProfit(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
         updatePoolConfigData(overrides?: CallOverrides): Promise<void>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
         withdraw(to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
     };
     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;
         'Initialized(uint8)'(version?: null): InitializedEventFilter;
         Initialized(version?: null): InitializedEventFilter;
         'PoolConfigCacheUpdated(address)'(poolConfig?: PromiseOrValue<string> | null): PoolConfigCacheUpdatedEventFilter;
         PoolConfigCacheUpdated(poolConfig?: PromiseOrValue<string> | null): PoolConfigCacheUpdatedEventFilter;
         'PoolConfigChanged(address,address)'(newPoolConfig?: PromiseOrValue<string> | null, oldPoolConfig?: PromiseOrValue<string> | null): PoolConfigChangedEventFilter;
         PoolConfigChanged(newPoolConfig?: PromiseOrValue<string> | null, oldPoolConfig?: PromiseOrValue<string> | null): PoolConfigChangedEventFilter;
+        'Upgraded(address)'(implementation?: PromiseOrValue<string> | null): UpgradedEventFilter;
+        Upgraded(implementation?: PromiseOrValue<string> | null): UpgradedEventFilter;
     };
     estimateGas: {
         addUnprocessedProfit(tranche: PromiseOrValue<string>, profit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
@@ -193,26 +252,33 @@ export interface PoolSafe extends BaseContract {
         deposit(from: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
-        getAvailableLiquidityForFees(overrides?: CallOverrides): Promise<BigNumber>;
-        getPoolLiquidity(overrides?: CallOverrides): Promise<BigNumber>;
+        getAvailableBalanceForFees(overrides?: CallOverrides): Promise<BigNumber>;
+        getAvailableBalanceForPool(overrides?: CallOverrides): Promise<BigNumber>;
         initialize(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
         pool(overrides?: CallOverrides): Promise<BigNumber>;
         poolConfig(overrides?: CallOverrides): Promise<BigNumber>;
         poolFeeManager(overrides?: CallOverrides): Promise<BigNumber>;
+        proxiableUUID(overrides?: CallOverrides): Promise<BigNumber>;
         resetUnprocessedProfit(overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
         setPoolConfig(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
-        totalLiquidity(overrides?: CallOverrides): Promise<BigNumber>;
+        totalBalance(overrides?: CallOverrides): Promise<BigNumber>;
         underlyingToken(overrides?: CallOverrides): Promise<BigNumber>;
         unprocessedTrancheProfit(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
         updatePoolConfigData(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>;
         withdraw(to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
@@ -224,26 +290,33 @@ export interface PoolSafe extends BaseContract {
         deposit(from: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
-        getAvailableLiquidityForFees(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        getPoolLiquidity(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getAvailableBalanceForFees(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getAvailableBalanceForPool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         initialize(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
         pool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         poolConfig(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         poolFeeManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        proxiableUUID(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         resetUnprocessedProfit(overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
         setPoolConfig(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
-        totalLiquidity(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalBalance(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         underlyingToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         unprocessedTrancheProfit(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         updatePoolConfigData(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>;
         withdraw(to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;

package/dist/cjs/v2/abis/types/factories/PoolSafe__factory.d.ts

@@ -4,20 +4,41 @@ import type { PoolSafe, PoolSafeInterface } from '../PoolSafe';
 export declare class PoolSafe__factory {
     static readonly abi: readonly [{
         readonly inputs: readonly [];
-        readonly name: "notAuthorizedCaller";
+        readonly name: "AuthorizedContractCallerRequired";
         readonly type: "error";
     }, {
         readonly inputs: readonly [];
-        readonly name: "notPool";
+        readonly name: "TrancheRequired";
         readonly type: "error";
     }, {
         readonly inputs: readonly [];
-        readonly name: "todo";
+        readonly name: "ZeroAddressProvided";
         readonly type: "error";
     }, {
-        readonly inputs: readonly [];
-        readonly name: "zeroAddressProvided";
-        readonly type: "error";
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: false;
+            readonly internalType: "address";
+            readonly name: "previousAdmin";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "address";
+            readonly name: "newAdmin";
+            readonly type: "address";
+        }];
+        readonly name: "AdminChanged";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "beacon";
+            readonly type: "address";
+        }];
+        readonly name: "BeaconUpgraded";
+        readonly type: "event";
     }, {
         readonly anonymous: false;
         readonly inputs: readonly [{
@@ -53,6 +74,16 @@ export declare class PoolSafe__factory {
         }];
         readonly name: "PoolConfigChanged";
         readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "implementation";
+            readonly type: "address";
+        }];
+        readonly name: "Upgraded";
+        readonly type: "event";
     }, {
         readonly inputs: readonly [{
             readonly internalType: "address";
@@ -83,20 +114,20 @@ export declare class PoolSafe__factory {
         readonly type: "function";
     }, {
         readonly inputs: readonly [];
-        readonly name: "getAvailableLiquidityForFees";
+        readonly name: "getAvailableBalanceForFees";
         readonly outputs: readonly [{
             readonly internalType: "uint256";
-            readonly name: "liquidity";
+            readonly name: "availableBalance";
             readonly type: "uint256";
         }];
         readonly stateMutability: "view";
         readonly type: "function";
     }, {
         readonly inputs: readonly [];
-        readonly name: "getPoolLiquidity";
+        readonly name: "getAvailableBalanceForPool";
         readonly outputs: readonly [{
             readonly internalType: "uint256";
-            readonly name: "liquidity";
+            readonly name: "availableBalance";
             readonly type: "uint256";
         }];
         readonly stateMutability: "view";
@@ -141,6 +172,16 @@ export declare class PoolSafe__factory {
         }];
         readonly stateMutability: "view";
         readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "proxiableUUID";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
     }, {
         readonly inputs: readonly [];
         readonly name: "resetUnprocessedProfit";
@@ -159,7 +200,7 @@ export declare class PoolSafe__factory {
         readonly type: "function";
     }, {
         readonly inputs: readonly [];
-        readonly name: "totalLiquidity";
+        readonly name: "totalBalance";
         readonly outputs: readonly [{
             readonly internalType: "uint256";
             readonly name: "liquidity";
@@ -197,6 +238,30 @@ export declare class PoolSafe__factory {
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
         readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "newImplementation";
+            readonly type: "address";
+        }];
+        readonly name: "upgradeTo";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "newImplementation";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly name: "upgradeToAndCall";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+        readonly type: "function";
     }, {
         readonly inputs: readonly [{
             readonly internalType: "address";