@gearbox-protocol/sdk 3.0.0-next.5 → 3.0.0-next.50

package/lib/parsers/creditFacadeParser.js

@@ -4,17 +4,24 @@ exports.CreditFacadeParser = void 0;
 const types_1 = require("../types");
 const abstractParser_1 = require("./abstractParser");
 class CreditFacadeParser extends abstractParser_1.AbstractParser {
-    constructor(token) {
+    version;
+    constructor(token, version) {
         super(token);
-        this.ifc = types_1.ICreditFacadeV2Extended__factory.createInterface();
+        this.version = version;
+        this.ifc =
+            version === 300
+                ? types_1.ICreditFacadeV3Multicall__factory.createInterface()
+                : types_1.ICreditFacadeV2Extended__factory.createInterface();
         this.adapterName = "CreditFacade";
     }
     parse(calldata) {
         const { functionFragment, functionName } = this.parseSelector(calldata);
         switch (functionFragment.name) {
             case "addCollateral": {
-                const [onBehalf, token, amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(onBehalf: ${onBehalf}, token: ${this.tokenSymbol(token)}, amount: ${this.formatAmount(amount)})`;
+                const r = this.decodeFunctionData(functionFragment, calldata);
+                const token = r[0];
+                const amount = r[1];
+                return `${functionName}(token: ${this.tokenSymbol(token)}, amount: ${this.formatAmount(amount)})`;
             }
             case "increaseDebt":
             case "decreaseDebt": {
@@ -26,12 +33,17 @@ class CreditFacadeParser extends abstractParser_1.AbstractParser {
                 const [address] = this.decodeFunctionData(functionFragment, calldata);
                 return `${functionName}(token: ${this.tokenSymbol(address)})`;
             }
+            case "updateQuota": {
+                const [address, quotaUpdate, minQuota] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(token: ${this.tokenSymbol(address)}, quotaUpdate: ${this.formatAmount(quotaUpdate)}, minQuota: ${this.formatAmount(minQuota)})`;
+            }
             case "revertIfReceivedLessThan": {
                 const [balances] = this.decodeFunctionData(functionFragment, calldata);
                 const balancesStr = balances
                     .map(b => {
+                    const balance = "balance" in b ? b.balance : b.amount;
                     const symbol = this.tokenSymbol(b.token);
-                    return `${symbol}: ${this.formatBN(b.balance, symbol)}`;
+                    return `${symbol}: ${this.formatBN(balance, symbol)}`;
                 })
                     .join(", ");
                 return `${functionName}(${balancesStr})`;

package/lib/parsers/creditFacadeParser.spec.js

@@ -6,14 +6,13 @@ const types_1 = require("../types");
 const creditFacadeParser_1 = require("./creditFacadeParser");
 describe("CreditFacadeParser test", () => {
     it("all functions works well", () => {
-        let parser = new creditFacadeParser_1.CreditFacadeParser("DAI");
+        let parser = new creditFacadeParser_1.CreditFacadeParser("DAI", 1);
         const ifc = types_1.ICreditFacadeV2Extended__factory.createInterface();
         let parsed = parser.parse(ifc.encodeFunctionData("addCollateral", [
-            sdk_gov_1.DUMB_ADDRESS,
             sdk_gov_1.tokenDataByNetwork.Mainnet.WBTC,
             (sdk_gov_1.WAD * 444n) / 10n,
         ]));
-        (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].addCollateral(onBehalf: 0xC4375B7De8af5a38a93548eb8453a498222C4fF2, token: WBTC, amount: 44.40 [44400000000000000000])", "Incorrect parse addCollateral");
+        (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].addCollateral(token: WBTC, amount: 44.40 [44400000000000000000])", "Incorrect parse addCollateral");
         parsed = parser.parse(ifc.encodeFunctionData("increaseDebt", [(sdk_gov_1.WAD * 414n) / 10n]));
         (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].increaseDebt(amount: 41.40 [41400000000000000000])", "Incorrect parse increaseDebt");
         parsed = parser.parse(ifc.encodeFunctionData("decreaseDebt", [(sdk_gov_1.WAD * 334n) / 10n]));

package/lib/parsers/curveAdapterParser.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CurveAdapterParser = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 const abstractParser_1 = require("./abstractParser");
 class CurveAdapterParser extends abstractParser_1.AbstractParser {
     lpToken;
@@ -54,7 +53,7 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
                 const jSym = functionFragment.name === "exchange_all_underlying"
                     ? this.getUnderlyingTokenByIndex(j)
                     : this.getTokenByIndex(j);
-                return `${functionName}(i: ${iSym}, j: ${jSym}, rateMinRAY: ${(0, formatter_1.formatBN)(rateMinRAY, 27)}`;
+                return `${functionName}(i: ${iSym}, j: ${jSym}, rateMinRAY: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)}`;
             }
             case "add_liquidity_one_coin": {
                 const [amount, i, minAmount] = this.decodeFunctionData(functionFragment, calldata);
@@ -64,7 +63,7 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
             case "add_all_liquidity_one_coin":
             case "remove_all_liquidity_one_coin": {
                 const [i, rateMinRAY] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(i: ${this.getTokenByIndex(i)}, rateMinRAY: ${(0, formatter_1.formatBN)(rateMinRAY, 27)})`;
+                return `${functionName}(i: ${this.getTokenByIndex(i)}, rateMinRAY: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)})`;
             }
             case "add_liquidity": {
                 const [amounts, minAmount] = this.decodeFunctionData(functionFragment, calldata);

package/lib/parsers/txParser.d.ts

@@ -1,5 +1,5 @@
 import { NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
-import { MultiCallStructOutput } from "../types/IRouter";
+import { MultiCall } from "../pathfinder/core";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export interface AdapterForParser {
@@ -19,15 +19,15 @@ export declare class TxParser {
         args: any;
     };
     static getParseData(address: string): ParseData;
-    static parseMultiCall(calls: Array<MultiCallStructOutput>): Array<string>;
-    static parseToObjectMultiCall(calls: Array<MultiCallStructOutput>): {
+    static parseMultiCall(calls: Array<MultiCall>): Array<string>;
+    static parseToObjectMultiCall(calls: Array<MultiCall>): {
         address: string;
         functionFragment: import("ethers/lib/utils").FunctionFragment;
         args: any;
     }[];
     static addAdapters(adapters: Array<AdapterForParser>): void;
     static addContracts(network: NetworkType): void;
-    static addCreditFacade(creditFacade: string, underlying: SupportedToken): void;
+    static addCreditFacade(creditFacade: string, underlying: SupportedToken, version: number): void;
     static addTokens(network: NetworkType): void;
     static addPriceOracle(address: string): void;
     static addAddressProvider(address: string): void;

package/lib/parsers/txParser.js

@@ -22,7 +22,13 @@ class TxParser {
     static parsers = {};
     static parse(address, calldata) {
         const parser = TxParser.getParser(address);
-        return parser.parse(calldata);
+        try {
+            return parser.parse(calldata);
+        }
+        catch (e) {
+            console.error(`Error while parsing ${address}`, parser, e);
+            return "Parsing error";
+        }
     }
     static parseToObject(address, calldata) {
         const parser = TxParser.getParser(address);
@@ -61,8 +67,8 @@ class TxParser {
             }
         });
     }
-    static addCreditFacade(creditFacade, underlying) {
-        TxParser._addParser(creditFacade, new creditFacadeParser_1.CreditFacadeParser(underlying));
+    static addCreditFacade(creditFacade, underlying, version) {
+        TxParser._addParser(creditFacade, new creditFacadeParser_1.CreditFacadeParser(underlying, version));
     }
     static addTokens(network) {
         sdk_gov_1.TypedObjectUtils.entries(sdk_gov_1.tokenDataByNetwork[network]).forEach(([s, t]) => {

package/lib/parsers/uniV2AdapterParser.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniswapV2AdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 const abstractParser_1 = require("./abstractParser");
 class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
@@ -41,7 +41,7 @@ class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
             }
             case "swapAllTokensForTokens": {
                 const [rateMinRAY, path] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(rate: ${(0, formatter_1.formatBN)(rateMinRAY, 27)}, path: [${path
+                return `${functionName}(rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)}, path: [${path
                     .map(r => this.tokenSymbol(r))
                     .join(" => ")}])`;
             }

package/lib/parsers/uniV3AdapterParser.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniswapV3AdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 const abstractParser_1 = require("./abstractParser");
 class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
@@ -26,7 +26,7 @@ class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
                 const { params: { tokenIn, tokenOut, fee, rateMinRAY }, } = this.decodeFunctionData(functionFragment, calldata);
                 const tokenInSym = this.tokenSymbol(tokenIn);
                 const tokenOutSym = this.tokenSymbol(tokenOut);
-                return `${functionName}(rate: ${(0, formatter_1.formatBN)(rateMinRAY, 27)},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
+                return `${functionName}(rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
             case "exactInput": {
                 const { params: { amountIn, amountOutMinimum, path }, } = this.decodeFunctionData(functionFragment, calldata);
@@ -38,7 +38,7 @@ class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
             case "exactAllInput": {
                 const { params: { rateMinRAY, path }, } = this.decodeFunctionData(functionFragment, calldata);
                 const pathStr = this.trackInputPath(path);
-                return `${functionName}(rate: ${(0, formatter_1.formatBN)(rateMinRAY, 27)},  path: ${pathStr}`;
+                return `${functionName}(rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${pathStr}`;
             }
             case "exactOutput": {
                 const { params: { amountInMaximum, amountOut, path }, } = this.decodeFunctionData(functionFragment, calldata);

package/lib/pathfinder/core.d.ts

@@ -1,12 +1,12 @@
+import { ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
+import { MultiCallStructOutput, SwapTaskStructOutput } from "../types/interfaces/IRouter";
 export declare enum SwapOperation {
     EXACT_INPUT = 0,
     EXACT_INPUT_ALL = 1,
     EXACT_OUTPUT = 2
 }
-export interface MultiCall {
-    target: string;
-    callData: string;
-}
+export type MultiCall = ExcludeArrayProps<MultiCallStructOutput>;
+export type SwapTask = ExcludeArrayProps<SwapTaskStructOutput>;
 export interface PathFinderResult {
     amount: bigint;
     calls: Array<MultiCall>;

package/lib/pathfinder/pathOptions.d.ts

@@ -1,4 +1,4 @@
-import { CurveLPToken, NetworkType } from "@gearbox-protocol/sdk-gov";
+import { BalancerLPToken, CurveLPToken, NetworkType } from "@gearbox-protocol/sdk-gov";
 import { CaTokenBalance } from "../payload/creditAccount";
 export interface PathOption {
     target: string;
@@ -10,6 +10,7 @@ export type BalanceInterface = Pick<CaTokenBalance, "balance">;
 export declare class PathOptionFactory {
     static generatePathOptions(balances: Record<string, BalanceInterface>, loopsInTx: number): Array<PathOptionSerie>;
     static getCurvePools(balances: Record<string, BalanceInterface>): Array<CurveLPToken>;
+    static getBalancerPools(balances: Record<string, BalanceInterface>): Array<BalancerLPToken>;
     static next(path: PathOptionSerie): PathOptionSerie;
     static detectNetwork(underlying: string): NetworkType;
 }

package/lib/pathfinder/pathOptions.js

@@ -5,8 +5,9 @@ const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 class PathOptionFactory {
     static generatePathOptions(balances, loopsInTx) {
         const curvePools = PathOptionFactory.getCurvePools(balances);
+        const balancerPools = PathOptionFactory.getBalancerPools(balances);
         const network = PathOptionFactory.detectNetwork(Object.keys(balances)[0]);
-        const initPO = curvePools.map(symbol => {
+        const curveInitPO = curvePools.map(symbol => {
             return {
                 target: sdk_gov_1.tokenDataByNetwork[network][symbol],
                 option: 0,
@@ -14,6 +15,14 @@ class PathOptionFactory {
                     .tokens.length,
             };
         });
+        const balancerInitPO = balancerPools.map(symbol => {
+            return {
+                target: sdk_gov_1.tokenDataByNetwork[network][symbol],
+                option: 0,
+                totalOptions: sdk_gov_1.balancerLpTokens[symbol].underlying.length,
+            };
+        });
+        const initPO = [...curveInitPO, ...balancerInitPO];
         const totalLoops = initPO.reduce((acc, item) => acc * item.totalOptions, 1);
         const result = [];
         let currentPo = [...initPO];
@@ -56,6 +65,16 @@ class PathOptionFactory {
         ]);
         return Array.from(curveSet.values());
     }
+    static getBalancerPools(balances) {
+        const result = [];
+        for (const [token, { balance }] of Object.entries(balances)) {
+            const symbol = sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()];
+            if ((0, sdk_gov_1.isBalancerLPToken)(symbol) && (0, sdk_gov_1.toBigInt)(balance) > 1) {
+                result.push(symbol);
+            }
+        }
+        return result;
+    }
     static next(path) {
         let newPath = [...path];
         for (let i = path.length - 1; i >= 0; i--) {

package/lib/pathfinder/pathOptions.spec.js

@@ -61,7 +61,7 @@ describe("PathOptionFactory test", () => {
             [sdk_gov_1.tokenDataByNetwork.Mainnet["3Crv"]]: { balance: 200n },
             [sdk_gov_1.tokenDataByNetwork.Mainnet.USDC]: { balance: 200n },
             [sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX3CRV]: { balance: 200n },
-            [sdk_gov_1.tokenDataByNetwork.Mainnet.LUSD3CRV]: { balance: 200n },
+            [sdk_gov_1.tokenDataByNetwork.Mainnet["50OHM_50DAI"]]: { balance: 200n },
         };
         const result = pathOptions_1.PathOptionFactory.generatePathOptions(balances, 4);
         const expected = [
@@ -76,7 +76,7 @@ describe("PathOptionFactory test", () => {
                 totalOptions: 2,
             },
             {
-                target: sdk_gov_1.tokenDataByNetwork.Mainnet.LUSD3CRV,
+                target: sdk_gov_1.tokenDataByNetwork.Mainnet["50OHM_50DAI"],
                 option: 0,
                 totalOptions: 2,
             },

package/lib/pathfinder/pathfinder.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathFinder = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const ethers_1 = require("ethers");
 const types_1 = require("../types");
 const pathOptions_1 = require("./pathOptions");
 const MAX_GAS_PER_ROUTE = 200e6;
@@ -12,7 +13,7 @@ class PathFinder {
     static connectors = [
         "USDC",
         "WETH",
-        "DAI",
+        "USDT",
         "FRAX",
     ];
     _connectors;
@@ -32,8 +33,8 @@ class PathFinder {
             tokenOut: sdk_gov_1.tokenDataByNetwork[this.network][tokenOut] ||
                 tokenOut,
             connectors,
-            amount: amount,
-            slippage,
+            amount: ethers_1.BigNumber.from(amount),
+            slippage: ethers_1.BigNumber.from(slippage),
             externalSlippage: false,
         };
         const results = await this.pathFinder.callStatic.findAllSwaps(swapTask, {

package/lib/pathfinder/pathfinder.spec.js

@@ -28,11 +28,13 @@ describe("PathFinder test", () => {
             [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: true,
             [sdk_gov_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()]: true,
             [sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX.toLowerCase()]: true,
+            [sdk_gov_1.tokenDataByNetwork.Mainnet.USDT.toLowerCase()]: true,
         };
         (0, chai_1.expect)(pf.getAvailableConnectors(allowedTokens)).to.be.deep.equal([
             sdk_gov_1.tokenDataByNetwork.Mainnet.USDC.toLowerCase(),
             sdk_gov_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase(),
-            sdk_gov_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase(),
+            // tokenDataByNetwork.Mainnet.DAI.toLowerCase(),
+            sdk_gov_1.tokenDataByNetwork.Mainnet.USDT.toLowerCase(),
             sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX.toLowerCase(),
         ]);
     });

package/lib/payload/creditAccount.d.ts

@@ -1,6 +1,6 @@
 import { ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
 import { CreditAccountDataStructOutput, ScheduledWithdrawalStructOutput, TokenBalanceStructOutput } from "../types/IDataCompressorV3_00";
-import { BigintifyProps } from "../utils/types";
+import { BigintifyProps, PartialKeys } from "../utils/types";
 export type CaTokenBalance = BigintifyProps<ExcludeArrayProps<TokenBalanceStructOutput>>;
 export type ScheduledWithdrawal = BigintifyProps<ExcludeArrayProps<ScheduledWithdrawalStructOutput>>;
-export type CreditAccountDataPayload = ExcludeArrayProps<CreditAccountDataStructOutput>;
+export type CreditAccountDataPayload = PartialKeys<ExcludeArrayProps<CreditAccountDataStructOutput>, "accruedInterest" | "accruedFees" | "healthFactor" | "totalValue">;

package/lib/payload/gauge.d.ts

@@ -0,0 +1,12 @@
+import { AwaitedRes, ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
+import { IGearStakingV3 } from "../types";
+import { GaugeInfoStructOutput, GaugeQuotaParamsStructOutput } from "../types/IDataCompressorV3_00";
+import { BigintifyProps } from "../utils/types";
+export type GaugeQuotaParams = BigintifyProps<ExcludeArrayProps<GaugeQuotaParamsStructOutput>>;
+export type GaugeDataPayload = ExcludeArrayProps<GaugeInfoStructOutput>;
+export interface GaugeStakingDataPayload {
+    availableBalance: AwaitedRes<IGearStakingV3["availableBalance"]>;
+    totalBalance: AwaitedRes<IGearStakingV3["balanceOf"]>;
+    epoch: AwaitedRes<IGearStakingV3["getCurrentEpoch"]>;
+    withdrawableAmounts: AwaitedRes<IGearStakingV3["getWithdrawableAmounts"]>;
+}

package/lib/payload/pool.d.ts

@@ -1,10 +1,15 @@
 import { ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
 import { BigNumberish } from "ethers";
+import { ZapperInfoStructOutput } from "../types/IDataCompressorV2_10";
 import { LinearModelStructOutput, PoolDataStructOutput } from "../types/IDataCompressorV3_00";
-export type PoolDataPayload = ExcludeArrayProps<PoolDataStructOutput>;
+export type PoolDataPayload = Omit<ExcludeArrayProps<PoolDataStructOutput>, "zappers"> & {
+    zappers: Array<PoolZapper>;
+    supplyAPY7D: number | undefined;
+};
 export type LinearModel = Omit<ExcludeArrayProps<LinearModelStructOutput>, "version"> & {
     version: number;
 };
+export type PoolZapper = ExcludeArrayProps<ZapperInfoStructOutput>;
 export interface ChartsPoolDataPayload {
     addr: string;
     dieselToken: string;

package/lib/types/IAirdropDistributor.sol/IAirdropDistributor.d.ts

@@ -0,0 +1,124 @@
+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 IAirdropDistributorInterface extends utils.Interface {
+    functions: {
+        "claim(uint256,address,uint256,bytes32[])": FunctionFragment;
+        "claimed(address)": FunctionFragment;
+        "merkleRoot()": FunctionFragment;
+        "token()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "claim" | "claimed" | "merkleRoot" | "token"): FunctionFragment;
+    encodeFunctionData(functionFragment: "claim", values: [
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BytesLike>[]
+    ]): string;
+    encodeFunctionData(functionFragment: "claimed", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "merkleRoot", values?: undefined): string;
+    encodeFunctionData(functionFragment: "token", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimed", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "merkleRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
+    events: {
+        "Claimed(address,uint256,bool)": EventFragment;
+        "RootUpdated(bytes32,bytes32)": EventFragment;
+        "TokenAllocated(address,uint8,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "Claimed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RootUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TokenAllocated"): EventFragment;
+}
+export interface ClaimedEventObject {
+    account: string;
+    amount: BigNumber;
+    historic: boolean;
+}
+export type ClaimedEvent = TypedEvent<[
+    string,
+    BigNumber,
+    boolean
+], ClaimedEventObject>;
+export type ClaimedEventFilter = TypedEventFilter<ClaimedEvent>;
+export interface RootUpdatedEventObject {
+    oldRoot: string;
+    newRoot: string;
+}
+export type RootUpdatedEvent = TypedEvent<[
+    string,
+    string
+], RootUpdatedEventObject>;
+export type RootUpdatedEventFilter = TypedEventFilter<RootUpdatedEvent>;
+export interface TokenAllocatedEventObject {
+    account: string;
+    campaignId: number;
+    amount: BigNumber;
+}
+export type TokenAllocatedEvent = TypedEvent<[
+    string,
+    number,
+    BigNumber
+], TokenAllocatedEventObject>;
+export type TokenAllocatedEventFilter = TypedEventFilter<TokenAllocatedEvent>;
+export interface IAirdropDistributor extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IAirdropDistributorInterface;
+    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: {
+        claim(index: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, totalAmount: PromiseOrValue<BigNumberish>, merkleProof: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        claimed(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        merkleRoot(overrides?: CallOverrides): Promise<[string]>;
+        token(overrides?: CallOverrides): Promise<[string]>;
+    };
+    claim(index: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, totalAmount: PromiseOrValue<BigNumberish>, merkleProof: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    claimed(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    merkleRoot(overrides?: CallOverrides): Promise<string>;
+    token(overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        claim(index: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, totalAmount: PromiseOrValue<BigNumberish>, merkleProof: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<void>;
+        claimed(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        merkleRoot(overrides?: CallOverrides): Promise<string>;
+        token(overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {
+        "Claimed(address,uint256,bool)"(account?: PromiseOrValue<string> | null, amount?: null, historic?: PromiseOrValue<boolean> | null): ClaimedEventFilter;
+        Claimed(account?: PromiseOrValue<string> | null, amount?: null, historic?: PromiseOrValue<boolean> | null): ClaimedEventFilter;
+        "RootUpdated(bytes32,bytes32)"(oldRoot?: null, newRoot?: PromiseOrValue<BytesLike> | null): RootUpdatedEventFilter;
+        RootUpdated(oldRoot?: null, newRoot?: PromiseOrValue<BytesLike> | null): RootUpdatedEventFilter;
+        "TokenAllocated(address,uint8,uint256)"(account?: PromiseOrValue<string> | null, campaignId?: PromiseOrValue<BigNumberish> | null, amount?: null): TokenAllocatedEventFilter;
+        TokenAllocated(account?: PromiseOrValue<string> | null, campaignId?: PromiseOrValue<BigNumberish> | null, amount?: null): TokenAllocatedEventFilter;
+    };
+    estimateGas: {
+        claim(index: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, totalAmount: PromiseOrValue<BigNumberish>, merkleProof: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        claimed(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        merkleRoot(overrides?: CallOverrides): Promise<BigNumber>;
+        token(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        claim(index: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, totalAmount: PromiseOrValue<BigNumberish>, merkleProof: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        claimed(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        merkleRoot(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        token(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/lib/types/IAirdropDistributor.sol/IAirdropDistributorEvents.d.ts

@@ -0,0 +1,73 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, Signer, utils } from "ethers";
+import type { EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../common";
+export interface IAirdropDistributorEventsInterface extends utils.Interface {
+    functions: {};
+    events: {
+        "Claimed(address,uint256,bool)": EventFragment;
+        "RootUpdated(bytes32,bytes32)": EventFragment;
+        "TokenAllocated(address,uint8,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "Claimed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RootUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TokenAllocated"): EventFragment;
+}
+export interface ClaimedEventObject {
+    account: string;
+    amount: BigNumber;
+    historic: boolean;
+}
+export type ClaimedEvent = TypedEvent<[
+    string,
+    BigNumber,
+    boolean
+], ClaimedEventObject>;
+export type ClaimedEventFilter = TypedEventFilter<ClaimedEvent>;
+export interface RootUpdatedEventObject {
+    oldRoot: string;
+    newRoot: string;
+}
+export type RootUpdatedEvent = TypedEvent<[
+    string,
+    string
+], RootUpdatedEventObject>;
+export type RootUpdatedEventFilter = TypedEventFilter<RootUpdatedEvent>;
+export interface TokenAllocatedEventObject {
+    account: string;
+    campaignId: number;
+    amount: BigNumber;
+}
+export type TokenAllocatedEvent = TypedEvent<[
+    string,
+    number,
+    BigNumber
+], TokenAllocatedEventObject>;
+export type TokenAllocatedEventFilter = TypedEventFilter<TokenAllocatedEvent>;
+export interface IAirdropDistributorEvents extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IAirdropDistributorEventsInterface;
+    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: {
+        "Claimed(address,uint256,bool)"(account?: PromiseOrValue<string> | null, amount?: null, historic?: PromiseOrValue<boolean> | null): ClaimedEventFilter;
+        Claimed(account?: PromiseOrValue<string> | null, amount?: null, historic?: PromiseOrValue<boolean> | null): ClaimedEventFilter;
+        "RootUpdated(bytes32,bytes32)"(oldRoot?: null, newRoot?: PromiseOrValue<BytesLike> | null): RootUpdatedEventFilter;
+        RootUpdated(oldRoot?: null, newRoot?: PromiseOrValue<BytesLike> | null): RootUpdatedEventFilter;
+        "TokenAllocated(address,uint8,uint256)"(account?: PromiseOrValue<string> | null, campaignId?: PromiseOrValue<BigNumberish> | null, amount?: null): TokenAllocatedEventFilter;
+        TokenAllocated(account?: PromiseOrValue<string> | null, campaignId?: PromiseOrValue<BigNumberish> | null, amount?: null): TokenAllocatedEventFilter;
+    };
+    estimateGas: {};
+    populateTransaction: {};
+}

package/lib/types/IAirdropDistributor.sol/index.d.ts

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

package/lib/types/IConvexToken.d.ts

@@ -4,6 +4,7 @@ import type { Listener, Provider } from "@ethersproject/providers";
 import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "./common";
 export interface IConvexTokenInterface extends utils.Interface {
     functions: {
+        "EMISSIONS_MAX_SUPPLY()": FunctionFragment;
         "allowance(address,address)": FunctionFragment;
         "approve(address,uint256)": FunctionFragment;
         "balanceOf(address)": FunctionFragment;
@@ -16,7 +17,8 @@ export interface IConvexTokenInterface extends utils.Interface {
         "transferFrom(address,address,uint256)": FunctionFragment;
         "vecrvProxy()": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "allowance" | "approve" | "balanceOf" | "maxSupply" | "operator" | "reductionPerCliff" | "totalCliffs" | "totalSupply" | "transfer" | "transferFrom" | "vecrvProxy"): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: "EMISSIONS_MAX_SUPPLY" | "allowance" | "approve" | "balanceOf" | "maxSupply" | "operator" | "reductionPerCliff" | "totalCliffs" | "totalSupply" | "transfer" | "transferFrom" | "vecrvProxy"): FunctionFragment;
+    encodeFunctionData(functionFragment: "EMISSIONS_MAX_SUPPLY", values?: undefined): string;
     encodeFunctionData(functionFragment: "allowance", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
     encodeFunctionData(functionFragment: "approve", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
     encodeFunctionData(functionFragment: "balanceOf", values: [PromiseOrValue<string>]): string;
@@ -32,6 +34,7 @@ export interface IConvexTokenInterface extends utils.Interface {
         PromiseOrValue<BigNumberish>
     ]): string;
     encodeFunctionData(functionFragment: "vecrvProxy", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "EMISSIONS_MAX_SUPPLY", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
@@ -87,6 +90,7 @@ export interface IConvexToken extends BaseContract {
     once: OnEvent<this>;
     removeListener: OnEvent<this>;
     functions: {
+        EMISSIONS_MAX_SUPPLY(overrides?: CallOverrides): Promise<[BigNumber]>;
         allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
         approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
@@ -105,6 +109,7 @@ export interface IConvexToken extends BaseContract {
         }): Promise<ContractTransaction>;
         vecrvProxy(overrides?: CallOverrides): Promise<[string]>;
     };
+    EMISSIONS_MAX_SUPPLY(overrides?: CallOverrides): Promise<BigNumber>;
     allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
     approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
@@ -123,6 +128,7 @@ export interface IConvexToken extends BaseContract {
     }): Promise<ContractTransaction>;
     vecrvProxy(overrides?: CallOverrides): Promise<string>;
     callStatic: {
+        EMISSIONS_MAX_SUPPLY(overrides?: CallOverrides): Promise<BigNumber>;
         allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
         approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
         balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
@@ -142,6 +148,7 @@ export interface IConvexToken extends BaseContract {
         Transfer(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, value?: null): TransferEventFilter;
     };
     estimateGas: {
+        EMISSIONS_MAX_SUPPLY(overrides?: CallOverrides): Promise<BigNumber>;
         allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
         approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
@@ -161,6 +168,7 @@ export interface IConvexToken extends BaseContract {
         vecrvProxy(overrides?: CallOverrides): Promise<BigNumber>;
     };
     populateTransaction: {
+        EMISSIONS_MAX_SUPPLY(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;