@meterio/sumer-js 0.2.100 → 0.2.102

package/dist/nodejs/typechain/contracts/Bera/base/IStakingRewards.d.ts

@@ -0,0 +1,161 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface IStakingRewardsInterface extends Interface {
+    getFunction(nameOrSignature: "balanceOf" | "earned" | "getRewardForDuration" | "lastTimeRewardApplicable" | "lastUpdateTime" | "periodFinish" | "rewardPerToken" | "rewardPerTokenStored" | "rewardRate" | "rewards" | "rewardsDuration" | "totalSupply" | "undistributedRewards" | "userRewardPerTokenPaid"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardAdded" | "RewardPaid" | "RewardsDurationUpdated" | "Staked" | "Withdrawn"): EventFragment;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "earned", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getRewardForDuration", values?: undefined): string;
+    encodeFunctionData(functionFragment: "lastTimeRewardApplicable", values?: undefined): string;
+    encodeFunctionData(functionFragment: "lastUpdateTime", values?: undefined): string;
+    encodeFunctionData(functionFragment: "periodFinish", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewardPerToken", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewardPerTokenStored", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewardRate", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewards", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "rewardsDuration", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "undistributedRewards", values?: undefined): string;
+    encodeFunctionData(functionFragment: "userRewardPerTokenPaid", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "earned", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRewardForDuration", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lastTimeRewardApplicable", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lastUpdateTime", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "periodFinish", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardPerToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardPerTokenStored", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardsDuration", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "undistributedRewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "userRewardPerTokenPaid", data: BytesLike): Result;
+}
+export declare namespace RewardAddedEvent {
+    type InputTuple = [reward: BigNumberish];
+    type OutputTuple = [reward: bigint];
+    interface OutputObject {
+        reward: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RewardPaidEvent {
+    type InputTuple = [
+        account: AddressLike,
+        to: AddressLike,
+        reward: BigNumberish
+    ];
+    type OutputTuple = [account: string, to: string, reward: bigint];
+    interface OutputObject {
+        account: string;
+        to: string;
+        reward: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RewardsDurationUpdatedEvent {
+    type InputTuple = [newDuration: BigNumberish];
+    type OutputTuple = [newDuration: bigint];
+    interface OutputObject {
+        newDuration: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace StakedEvent {
+    type InputTuple = [account: AddressLike, amount: BigNumberish];
+    type OutputTuple = [account: string, amount: bigint];
+    interface OutputObject {
+        account: string;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace WithdrawnEvent {
+    type InputTuple = [account: AddressLike, amount: BigNumberish];
+    type OutputTuple = [account: string, amount: bigint];
+    interface OutputObject {
+        account: string;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface IStakingRewards extends BaseContract {
+    connect(runner?: ContractRunner | null): IStakingRewards;
+    waitForDeployment(): Promise<this>;
+    interface: IStakingRewardsInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    earned: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getRewardForDuration: TypedContractMethod<[], [bigint], "view">;
+    lastTimeRewardApplicable: TypedContractMethod<[], [bigint], "view">;
+    lastUpdateTime: TypedContractMethod<[], [bigint], "view">;
+    periodFinish: TypedContractMethod<[], [bigint], "view">;
+    rewardPerToken: TypedContractMethod<[], [bigint], "view">;
+    rewardPerTokenStored: TypedContractMethod<[], [bigint], "view">;
+    rewardRate: TypedContractMethod<[], [bigint], "view">;
+    rewards: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    rewardsDuration: TypedContractMethod<[], [bigint], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    undistributedRewards: TypedContractMethod<[], [bigint], "view">;
+    userRewardPerTokenPaid: TypedContractMethod<[
+        account: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "earned"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getRewardForDuration"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "lastTimeRewardApplicable"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "lastUpdateTime"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "periodFinish"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "rewardPerToken"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "rewardPerTokenStored"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "rewardRate"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "rewards"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "rewardsDuration"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "undistributedRewards"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "userRewardPerTokenPaid"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getEvent(key: "RewardAdded"): TypedContractEvent<RewardAddedEvent.InputTuple, RewardAddedEvent.OutputTuple, RewardAddedEvent.OutputObject>;
+    getEvent(key: "RewardPaid"): TypedContractEvent<RewardPaidEvent.InputTuple, RewardPaidEvent.OutputTuple, RewardPaidEvent.OutputObject>;
+    getEvent(key: "RewardsDurationUpdated"): TypedContractEvent<RewardsDurationUpdatedEvent.InputTuple, RewardsDurationUpdatedEvent.OutputTuple, RewardsDurationUpdatedEvent.OutputObject>;
+    getEvent(key: "Staked"): TypedContractEvent<StakedEvent.InputTuple, StakedEvent.OutputTuple, StakedEvent.OutputObject>;
+    getEvent(key: "Withdrawn"): TypedContractEvent<WithdrawnEvent.InputTuple, WithdrawnEvent.OutputTuple, WithdrawnEvent.OutputObject>;
+    filters: {
+        "RewardAdded(uint256)": TypedContractEvent<RewardAddedEvent.InputTuple, RewardAddedEvent.OutputTuple, RewardAddedEvent.OutputObject>;
+        RewardAdded: TypedContractEvent<RewardAddedEvent.InputTuple, RewardAddedEvent.OutputTuple, RewardAddedEvent.OutputObject>;
+        "RewardPaid(address,address,uint256)": TypedContractEvent<RewardPaidEvent.InputTuple, RewardPaidEvent.OutputTuple, RewardPaidEvent.OutputObject>;
+        RewardPaid: TypedContractEvent<RewardPaidEvent.InputTuple, RewardPaidEvent.OutputTuple, RewardPaidEvent.OutputObject>;
+        "RewardsDurationUpdated(uint256)": TypedContractEvent<RewardsDurationUpdatedEvent.InputTuple, RewardsDurationUpdatedEvent.OutputTuple, RewardsDurationUpdatedEvent.OutputObject>;
+        RewardsDurationUpdated: TypedContractEvent<RewardsDurationUpdatedEvent.InputTuple, RewardsDurationUpdatedEvent.OutputTuple, RewardsDurationUpdatedEvent.OutputObject>;
+        "Staked(address,uint256)": TypedContractEvent<StakedEvent.InputTuple, StakedEvent.OutputTuple, StakedEvent.OutputObject>;
+        Staked: TypedContractEvent<StakedEvent.InputTuple, StakedEvent.OutputTuple, StakedEvent.OutputObject>;
+        "Withdrawn(address,uint256)": TypedContractEvent<WithdrawnEvent.InputTuple, WithdrawnEvent.OutputTuple, WithdrawnEvent.OutputObject>;
+        Withdrawn: TypedContractEvent<WithdrawnEvent.InputTuple, WithdrawnEvent.OutputTuple, WithdrawnEvent.OutputObject>;
+    };
+}

package/dist/nodejs/typechain/contracts/Bera/base/IStakingRewards.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IStakingRewards.js.map

package/dist/nodejs/typechain/contracts/Bera/base/IStakingRewards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IStakingRewards.js","sourceRoot":"","sources":["../../../../../../src/typechain/contracts/Bera/base/IStakingRewards.ts"],"names":[],"mappings":""}

package/dist/nodejs/typechain/contracts/Bera/base/IStakingRewardsErrors.d.ts

@@ -0,0 +1,20 @@
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../../common";
+export interface IStakingRewardsErrorsInterface extends Interface {
+}
+export interface IStakingRewardsErrors extends BaseContract {
+    connect(runner?: ContractRunner | null): IStakingRewardsErrors;
+    waitForDeployment(): Promise<this>;
+    interface: IStakingRewardsErrorsInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    filters: {};
+}

package/dist/nodejs/typechain/contracts/Bera/base/IStakingRewardsErrors.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IStakingRewardsErrors.js.map

package/dist/nodejs/typechain/contracts/Bera/base/IStakingRewardsErrors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IStakingRewardsErrors.js","sourceRoot":"","sources":["../../../../../../src/typechain/contracts/Bera/base/IStakingRewardsErrors.ts"],"names":[],"mappings":""}

package/dist/nodejs/typechain/contracts/Bera/base/index.d.ts

@@ -0,0 +1,2 @@
+export type { IStakingRewards } from "./IStakingRewards";
+export type { IStakingRewardsErrors } from "./IStakingRewardsErrors";

package/dist/nodejs/typechain/contracts/Bera/base/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/nodejs/typechain/contracts/Bera/base/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../src/typechain/contracts/Bera/base/index.ts"],"names":[],"mappings":""}

package/dist/nodejs/typechain/contracts/Bera/index.d.ts

@@ -0,0 +1,5 @@
+import type * as base from "./base";
+export type { base };
+export type { CBeraVault } from "./CBeraVault";
+export type { IPOLErrors } from "./IPOLErrors";
+export type { IRewardVault } from "./IRewardVault";

package/dist/nodejs/typechain/contracts/Bera/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/nodejs/typechain/contracts/Bera/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/typechain/contracts/Bera/index.ts"],"names":[],"mappings":""}

package/dist/nodejs/typechain/contracts/Interfaces/index.d.ts

@@ -10,6 +10,7 @@ export type { IEIP712 } from "./IEIP712";
 export type { IGovernorAlpha } from "./IGovernorAlpha";
 export type { IGovernorBravo } from "./IGovernorBravo";
 export type { IInterestRateModel } from "./IInterestRateModel";
+export type { ILayerBank } from "./ILayerBank";
 export type { IPMarket } from "./IPMarket";
 export type { IPPrincipalToken } from "./IPPrincipalToken";
 export type { IPYieldToken } from "./IPYieldToken";

package/dist/nodejs/typechain/contracts/Oracle/index.d.ts

@@ -1,9 +1,21 @@
+import type * as api3AdapterSol from "./API3Adapter.sol";
+export type { api3AdapterSol };
+import type * as layerBankAdapterSol from "./LayerBankAdapter.sol";
+export type { layerBankAdapterSol };
 import type * as priceOracleSol from "./PriceOracle.sol";
 export type { priceOracleSol };
+import type * as stakedAngleAdapterSol from "./StakedAngleAdapter.sol";
+export type { stakedAngleAdapterSol };
 import type * as wstEthAdapterSol from "./WstETHAdapter.sol";
 export type { wstEthAdapterSol };
 import type * as wstMtrgAdapterSol from "./WstMTRGAdapter.sol";
 export type { wstMtrgAdapterSol };
+import type * as stCoreAdapterSol from "./stCoreAdapter.sol";
+export type { stCoreAdapterSol };
+import type * as stEurAdapterSol from "./stEURAdapter.sol";
+export type { stEurAdapterSol };
+import type * as stUsdAdapterSol from "./stUSDAdapter.sol";
+export type { stUsdAdapterSol };
 import type * as wstMtrgOracleSol from "./wstMTRGOracle.sol";
 export type { wstMtrgOracleSol };
 export type { FeedPriceOracle } from "./FeedPriceOracle";

package/dist/nodejs/typechain/contracts/index.d.ts

@@ -1,3 +1,5 @@
+import type * as bera from "./Bera";
+export type { bera };
 import type * as cToken from "./CToken";
 export type { cToken };
 import type * as comptroller from "./Comptroller";