@merkl/contracts 0.2.15 → 0.2.17

package/dist/src/BalancerGaugeFactory.d.ts

@@ -0,0 +1,77 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, 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 interface BalancerGaugeFactoryInterface extends utils.Interface {
+    functions: {
+        "create(address,uint256)": FunctionFragment;
+        "getGaugeImplementation()": FunctionFragment;
+        "isGaugeFromFactory(address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "create" | "getGaugeImplementation" | "isGaugeFromFactory"): FunctionFragment;
+    encodeFunctionData(functionFragment: "create", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "getGaugeImplementation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isGaugeFromFactory", values: [PromiseOrValue<string>]): string;
+    decodeFunctionResult(functionFragment: "create", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getGaugeImplementation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isGaugeFromFactory", data: BytesLike): Result;
+    events: {
+        "GaugeCreated(address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "GaugeCreated"): EventFragment;
+}
+export interface GaugeCreatedEventObject {
+    gauge: string;
+}
+export type GaugeCreatedEvent = TypedEvent<[string], GaugeCreatedEventObject>;
+export type GaugeCreatedEventFilter = TypedEventFilter<GaugeCreatedEvent>;
+export interface BalancerGaugeFactory extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: BalancerGaugeFactoryInterface;
+    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: {
+        create(pool: PromiseOrValue<string>, relativeWeightCap: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        getGaugeImplementation(overrides?: CallOverrides): Promise<[string]>;
+        isGaugeFromFactory(gauge: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+    };
+    create(pool: PromiseOrValue<string>, relativeWeightCap: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    getGaugeImplementation(overrides?: CallOverrides): Promise<string>;
+    isGaugeFromFactory(gauge: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    callStatic: {
+        create(pool: PromiseOrValue<string>, relativeWeightCap: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        getGaugeImplementation(overrides?: CallOverrides): Promise<string>;
+        isGaugeFromFactory(gauge: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    };
+    filters: {
+        "GaugeCreated(address)"(gauge?: PromiseOrValue<string> | null): GaugeCreatedEventFilter;
+        GaugeCreated(gauge?: PromiseOrValue<string> | null): GaugeCreatedEventFilter;
+    };
+    estimateGas: {
+        create(pool: PromiseOrValue<string>, relativeWeightCap: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        getGaugeImplementation(overrides?: CallOverrides): Promise<BigNumber>;
+        isGaugeFromFactory(gauge: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        create(pool: PromiseOrValue<string>, relativeWeightCap: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        getGaugeImplementation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isGaugeFromFactory(gauge: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/src/BalancerGaugeFactory.js

@@ -0,0 +1 @@
+export {};

package/dist/src/factories/BalancerGaugeFactory__factory.d.ts

@@ -0,0 +1,68 @@
+import { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { BalancerGaugeFactory, BalancerGaugeFactoryInterface } from "../BalancerGaugeFactory";
+export declare class BalancerGaugeFactory__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "contract IStakingLiquidityGauge";
+            readonly name: "gauge";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "constructor";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "gauge";
+            readonly type: "address";
+        }];
+        readonly name: "GaugeCreated";
+        readonly type: "event";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "pool";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "relativeWeightCap";
+            readonly type: "uint256";
+        }];
+        readonly name: "create";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getGaugeImplementation";
+        readonly outputs: readonly [{
+            readonly internalType: "contract ILiquidityGauge";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "gauge";
+            readonly type: "address";
+        }];
+        readonly name: "isGaugeFromFactory";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    static createInterface(): BalancerGaugeFactoryInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): BalancerGaugeFactory;
+}

package/dist/src/factories/BalancerGaugeFactory__factory.js

@@ -0,0 +1,95 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { Contract, utils } from "ethers";
+const _abi = [
+    {
+        inputs: [
+            {
+                internalType: "contract IStakingLiquidityGauge",
+                name: "gauge",
+                type: "address",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "gauge",
+                type: "address",
+            },
+        ],
+        name: "GaugeCreated",
+        type: "event",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "pool",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "relativeWeightCap",
+                type: "uint256",
+            },
+        ],
+        name: "create",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getGaugeImplementation",
+        outputs: [
+            {
+                internalType: "contract ILiquidityGauge",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "gauge",
+                type: "address",
+            },
+        ],
+        name: "isGaugeFromFactory",
+        outputs: [
+            {
+                internalType: "bool",
+                name: "",
+                type: "bool",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+export class BalancerGaugeFactory__factory {
+    static abi = _abi;
+    static createInterface() {
+        return new utils.Interface(_abi);
+    }
+    static connect(address, signerOrProvider) {
+        return new Contract(address, _abi, signerOrProvider);
+    }
+}

package/dist/src/factories/index.d.ts

@@ -56,6 +56,7 @@ export { Aura__factory } from "./Aura__factory";
 export { AuraOperator__factory } from "./AuraOperator__factory";
 export { BPAMOJob__factory } from "./BPAMOJob__factory";
 export { BalancerGauge__factory } from "./BalancerGauge__factory";
+export { BalancerGaugeFactory__factory } from "./BalancerGaugeFactory__factory";
 export { BalancerPool__factory } from "./BalancerPool__factory";
 export { BalancerSingleton__factory } from "./BalancerSingleton__factory";
 export { BalancerV3StablePool__factory } from "./BalancerV3StablePool__factory";

package/dist/src/factories/index.js

@@ -59,6 +59,7 @@ export { Aura__factory } from "./Aura__factory";
 export { AuraOperator__factory } from "./AuraOperator__factory";
 export { BPAMOJob__factory } from "./BPAMOJob__factory";
 export { BalancerGauge__factory } from "./BalancerGauge__factory";
+export { BalancerGaugeFactory__factory } from "./BalancerGaugeFactory__factory";
 export { BalancerPool__factory } from "./BalancerPool__factory";
 export { BalancerSingleton__factory } from "./BalancerSingleton__factory";
 export { BalancerV3StablePool__factory } from "./BalancerV3StablePool__factory";

package/dist/src/index.d.ts

@@ -269,6 +269,7 @@ export type { TermMaxFT } from "./TermMaxFT";
 export type { JonesDoubleRewardTracker } from "./JonesDoubleRewardTracker";
 export type { TermMaxMarket } from "./TermMaxMarket";
 export type { KilnFactory } from "./KilnFactory";
+export type { BalancerGaugeFactory } from "./BalancerGaugeFactory";
 export type { AlgebraIntegralV12NonFungibleManager } from "./AlgebraIntegralV12NonFungibleManager";
 export type { MaverickRewardVault } from "./MaverickRewardVault";
 export type { ERC4626 } from "./ERC4626";
@@ -406,6 +407,7 @@ export declare const FraxLendPairInterface: import("./FraxLendPair").FraxLendPai
 export declare const CtokenInterface: import("./Ctoken").CtokenInterface;
 export declare const GammaChefInterface: import("./GammaChef").GammaChefInterface;
 export declare const AlgebraIntegralV12FarmingCenterInterface: import("./AlgebraIntegralV12FarmingCenter").AlgebraIntegralV12FarmingCenterInterface;
+export declare const BalancerGaugeFactoryInterface: import("./BalancerGaugeFactory").BalancerGaugeFactoryInterface;
 export declare const MorphoBlueInterface: import("./MorphoBlue").MorphoBlueInterface;
 export declare const TwyneEulerCollateralVaultInterface: import("./TwyneEulerCollateralVault").TwyneEulerCollateralVaultInterface;
 export declare const BunniV2HubInterface: import("./BunniV2Hub").BunniV2HubInterface;

package/dist/src/index.js

@@ -148,6 +148,8 @@ import { GammaChef__factory } from "./factories/GammaChef__factory";
 export const GammaChefInterface = GammaChef__factory.createInterface();
 import { AlgebraIntegralV12FarmingCenter__factory } from "./factories/AlgebraIntegralV12FarmingCenter__factory";
 export const AlgebraIntegralV12FarmingCenterInterface = AlgebraIntegralV12FarmingCenter__factory.createInterface();
+import { BalancerGaugeFactory__factory } from "./factories/BalancerGaugeFactory__factory";
+export const BalancerGaugeFactoryInterface = BalancerGaugeFactory__factory.createInterface();
 import { MorphoBlue__factory } from "./factories/MorphoBlue__factory";
 export const MorphoBlueInterface = MorphoBlue__factory.createInterface();
 import { TwyneEulerCollateralVault__factory } from "./factories/TwyneEulerCollateralVault__factory";