@boostxyz/sdk 2.0.0-alpha.35 → 2.1.0

package/src/Incentives/AllowListIncentive.test.ts

@@ -1,6 +1,3 @@
-import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
-import { isAddress, pad, parseEther, zeroAddress } from "viem";
-import { beforeAll, describe, expect, test } from "vitest";
 import { accounts } from "@boostxyz/test/accounts";
 import {
   type Fixtures,
@@ -8,8 +5,11 @@ import {
   deployFixtures,
   freshBoost,
 } from "@boostxyz/test/helpers";
-import { PointsIncentive } from "./PointsIncentive";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { isAddress, pad, parseEther, zeroAddress } from "viem";
+import { beforeAll, describe, expect, test } from "vitest";
 import { Roles } from "../Deployable/DeployableTargetWithRBAC";
+import { PointsIncentive } from "./PointsIncentive";
 
 let fixtures: Fixtures;
 
@@ -86,6 +86,54 @@ describe("AllowListIncentive", () => {
     expect(await allowList.isAllowed(trustedSigner.account)).toBe(true);
   });
 
+  test("can test claimability", async () => {
+    // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+    const referrer = accounts.at(1)?.account!;
+    // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+    const trustedSigner = accounts.at(0)!;
+    const allowList = await loadFixture(freshAllowList(fixtures));
+    const allowListIncentive = new fixtures.bases.AllowListIncentive(
+      defaultOptions,
+      {
+        allowList: allowList.assertValidAddress(),
+        limit: 1n,
+      },
+    );
+    const boost = await freshBoost(fixtures, {
+      incentives: [allowListIncentive],
+    });
+    await allowList.grantManyRoles(
+      [allowListIncentive.assertValidAddress()],
+      [Roles.MANAGER],
+    );
+
+    const claimant = trustedSigner.account;
+    const incentiveData = pad("0xdef456232173821931823712381232131391321934");
+
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBeGreaterThan(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(true)
+
+    //await boost.validator.setValidatorCaller(boost.assertValidAddress());
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      { value: parseEther("0.000075"), account: trustedSigner.privateKey },
+    );
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBe(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(false)
+  });
+
   test("cannot claim twice", async () => {
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined
     const referrer = accounts.at(1)?.account!;

package/src/Incentives/AllowListIncentive.ts

@@ -278,6 +278,34 @@ export class AllowListIncentive extends DeployableTarget<
     });
   }
 
+  /**
+   * Check if an incentive can potentially be claimed by comparing limit and total claims. Does not take requesting user or underlying allowlist into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} - True if total claims is less than limit
+   */
+  public async canBeClaimed(params?: ReadParams) {
+    return (await this.getRemainingClaimPotential(params)) > 0n;
+  }
+
+  /**
+   * Check how many claims remain by comparing limit and total claims. Does not take requesting user or underlying allowlist into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>} - True if total claims is less than limit
+   */
+  public async getRemainingClaimPotential(params?: ReadParams) {
+    const [claims, limit] = await Promise.all([
+      this.claims(params),
+      this.limit(params),
+    ]);
+    return limit - claims;
+  }
+
   /**
    * @inheritdoc
    *

package/src/Incentives/CGDAIncentive.test.ts

@@ -1,7 +1,4 @@
 import { readMockErc20BalanceOf } from "@boostxyz/evm";
-import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
-import { isAddress, isAddressEqual, pad, parseEther, zeroAddress } from "viem";
-import { beforeAll, beforeEach, describe, expect, test } from "vitest";
 import { accounts } from "@boostxyz/test/accounts";
 import {
   type BudgetFixtures,
@@ -11,6 +8,9 @@ import {
   freshBoost,
   fundBudget,
 } from "@boostxyz/test/helpers";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { isAddress, isAddressEqual, pad, parseEther, zeroAddress } from "viem";
+import { beforeAll, beforeEach, describe, expect, test } from "vitest";
 import { CGDAIncentive } from "./CGDAIncentive";
 
 let fixtures: Fixtures, budgets: BudgetFixtures;
@@ -82,6 +82,51 @@ describe("CGDAIncentive", () => {
     ).toBe(1n);
   });
 
+  test("can get claimability", async () => {
+    // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+    const referrer = accounts.at(1)!.account!;
+    // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+    const trustedSigner = accounts.at(0)!;
+    const erc20Incentive = fixtures.core.CGDAIncentive({
+      asset: budgets.erc20.assertValidAddress(),
+      initialReward: 1n,
+      totalBudget: 2n,
+      rewardBoost: 1n,
+      rewardDecay: 1n,
+      manager: budgets.budget.assertValidAddress(),
+    });
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20Incentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveData = pad("0xdef456232173821931823712381232131391321934");
+
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBeGreaterThan(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(true)
+
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload
+    );
+
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBe(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(false)
+
+  });
+
   test("cannot claim twice", async () => {
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined
     const referrer = accounts.at(1)!.account!;

package/src/Incentives/CGDAIncentive.ts

@@ -34,6 +34,7 @@ import {
   type ReadParams,
   RegistryType,
   type WriteParams,
+  getErc20Balance,
 } from '../utils';
 
 export { cgdaIncentiveAbi };
@@ -380,6 +381,39 @@ export class CGDAIncentive extends DeployableTarget<
     });
   }
 
+  /**
+   * Check if any claims remain by comparing the incentive's balance against the current reward. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} - True if asset balance minus current reward is greater than 0
+   */
+  public async canBeClaimed(params?: ReadParams) {
+    return (await this.getRemainingClaimPotential(params)) > 0n;
+  }
+
+  /**
+   * Check how many claims remain by comparing the incentive's balance against the current reward. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>} - Asset balance minus current reward
+   */
+  public async getRemainingClaimPotential(params?: ReadParams) {
+    const [currentReward, currentBalance] = await Promise.all([
+      this.currentReward(params),
+      getErc20Balance(
+        this._config,
+        await this.asset(),
+        this.assertValidAddress(),
+        params,
+      ),
+    ]);
+    return currentBalance - currentReward;
+  }
+
   /**
    * Calculates the current reward based on the time since the last claim.
    * The reward is calculated based on the time since the last claim, the available budget, and the reward parameters. It increases linearly over time in the absence of claims, with each hour adding `rewardBoost` to the current reward, up to the available budget.

package/src/Incentives/ERC20Incentive.test.ts

@@ -85,6 +85,48 @@ describe("ERC20Incentive", () => {
     ).toBe(1n);
   });
 
+  test("can test claimability", async () => {
+    // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+    const referrer = accounts.at(1)!.account!,
+      // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+      trustedSigner = accounts.at(0)!;
+    const erc20Incentive = fixtures.core.ERC20Incentive({
+      asset: budgets.erc20.assertValidAddress(),
+      strategy: StrategyType.POOL,
+      reward: 1n,
+      limit: 1n,
+      manager: budgets.budget.assertValidAddress(),
+    });
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20Incentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveData = erc20Incentive.buildClaimData();
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBeGreaterThan(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(true)
+
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+    );
+
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBe(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(false)
+  });
+
   test("cannot claim twice", async () => {
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined
     const referrer = accounts.at(1)!.account!;

package/src/Incentives/ERC20Incentive.ts

@@ -439,6 +439,34 @@ export class ERC20Incentive extends DeployableTarget<
     return strategy === StrategyType.POOL ? limit * reward : reward;
   }
 
+  /**
+   * Check if any claims remain by comparing the incentive's total claims against its limit. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} - True if total claims is less than limit
+   */
+  public async canBeClaimed(params?: ReadParams) {
+    return (await this.getRemainingClaimPotential(params)) > 0n;
+  }
+
+  /**
+   * Check how many claims remain by comparing the incentive's total claims against its limit. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>} - True if total claims is less than limit
+   */
+  public async getRemainingClaimPotential(params?: ReadParams) {
+    const [claims, limit] = await Promise.all([
+      this.claims(params),
+      this.limit(params),
+    ]);
+    return limit - claims;
+  }
+
   /**
    * @inheritdoc
    *

package/src/Incentives/ERC20VariableIncentive.test.ts

@@ -16,8 +16,8 @@ import {
   zeroAddress
 } from "viem";
 import { beforeAll, beforeEach, describe, expect, test } from "vitest";
-import { ERC20VariableIncentive } from "./ERC20VariableIncentive";
 import { decodeClaimData } from "../Validators/Validator";
+import { ERC20VariableIncentive } from "./ERC20VariableIncentive";
 
 
 let fixtures: Fixtures, budgets: BudgetFixtures;
@@ -84,6 +84,46 @@ describe("ERC20VariableIncentive", () => {
     ).toBe(1n);
   });
 
+  test("can test claimability", async () => {
+    // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+    const referrer = accounts.at(1)!.account!,
+      // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+      trustedSigner = accounts.at(0)!;
+    const erc20VariableIncentive = new fixtures.bases.ERC20VariableIncentive(
+      defaultOptions,
+      {
+        asset: budgets.erc20.assertValidAddress(),
+        reward: 1n,
+        limit: 1n,
+        manager: zeroAddress,
+      },
+    );
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20VariableIncentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData: erc20VariableIncentive.buildClaimData(parseEther("1")),
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBeGreaterThan(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(true)
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+    );
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBe(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(false)
+  });
+
   test("cannot claim twice", async () => {
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined
     const referrer = accounts.at(1)!.account!;

package/src/Incentives/ERC20VariableIncentive.ts

@@ -367,6 +367,34 @@ export class ERC20VariableIncentive<
     return await this.limit(params);
   }
 
+  /**
+   * Check if any claims remain by comparing the incentive's total claimed amount against its limit. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} - True if limit minus total claimed is greater than 0
+   */
+  public async canBeClaimed(params?: ReadParams) {
+    return (await this.getRemainingClaimPotential(params)) > 0n;
+  }
+
+  /**
+   * Check how much of the underlying asset remains by comparing the the limit against the total amount claimed. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>} - Limit minus total claimed
+   */
+  public async getRemainingClaimPotential(params?: ReadParams) {
+    const [totalClaimed, limit] = await Promise.all([
+      this.totalClaimed(params),
+      this.limit(params),
+    ]);
+    return limit - totalClaimed;
+  }
+
   /**
    * Builds the claim data for the ERC20VariableIncentive.
    *

package/src/Incentives/PointsIncentive.test.ts

@@ -1,7 +1,4 @@
 import { readPointsBalanceOf, writePointsGrantRoles } from "@boostxyz/evm";
-import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
-import { isAddress, pad, parseEther, zeroAddress } from "viem";
-import { beforeAll, beforeEach, describe, expect, test } from "vitest";
 import type { MockPoints } from "@boostxyz/test/MockPoints";
 import { accounts } from "@boostxyz/test/accounts";
 import {
@@ -11,6 +8,9 @@ import {
   freshBoost,
   freshPoints,
 } from "@boostxyz/test/helpers";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { isAddress, pad, parseEther, zeroAddress } from "viem";
+import { beforeAll, beforeEach, describe, expect, test } from "vitest";
 import { bytes4 } from "../utils";
 import { PointsIncentive } from "./PointsIncentive";
 
@@ -81,6 +81,50 @@ describe("PointsIncentive", () => {
     ).toBe(1n);
   });
 
+  test("can test claimability", async () => {
+    // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+    const referrer = accounts.at(1)!.account!;
+    // biome-ignore lint/style/noNonNullAssertion: we know this is defined
+    const trustedSigner = accounts.at(0)!;
+    const pointsIncentive = fixtures.core.PointsIncentive({
+      venue: points.assertValidAddress(),
+      selector: bytes4("issue(address,uint256)"),
+      reward: 1n,
+      limit: 1n,
+    });
+    const boost = await freshBoost(fixtures, {
+      incentives: [pointsIncentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveData = pad("0xdef456232173821931823712381232131391321934");
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id,
+    });
+
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBeGreaterThan(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(true)
+
+    await writePointsGrantRoles(defaultOptions.config, {
+      address: points.assertValidAddress(),
+      args: [pointsIncentive.assertValidAddress(), 2n],
+      account: defaultOptions.account,
+    });
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+    );
+    expect(await boost.incentives.at(0)!.getRemainingClaimPotential()).toBe(0n)
+    expect(await boost.incentives.at(0)!.canBeClaimed()).toBe(false)
+  });
+
   test("cannot claim twice", async () => {
     const reward = 1n;
     // biome-ignore lint/style/noNonNullAssertion: we know this is defined

package/src/Incentives/PointsIncentive.ts

@@ -296,6 +296,34 @@ export class PointsIncentive extends DeployableTarget<
     });
   }
 
+  /**
+   * Check if any claims remain by comparing the incentive's total claims against its limit. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} - True if total claims is less than limit
+   */
+  public async canBeClaimed(params?: ReadParams) {
+    return (await this.getRemainingClaimPotential(params)) > 0n;
+  }
+
+  /**
+   * Check how many claims remain by comparing the incentive's total claims against its limit. Does not take requesting user's elligibility into account.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>} - True if total claims is less than limit
+   */
+  public async getRemainingClaimPotential(params?: ReadParams) {
+    const [claims, limit] = await Promise.all([
+      this.claims(params),
+      this.limit(params),
+    ]);
+    return limit - claims;
+  }
+
   /**
    * @inheritdoc
    *

package/src/index.ts

@@ -21,6 +21,7 @@ export * from './Budgets/Budget';
 // export * from './Budgets/SimpleBudget';
 // export * from './Budgets/VestingBudget';
 export * from './Budgets/ManagedBudget';
+export * from './Budgets/ManagedBudgetWithFees';
 
 // Deployable
 

package/src/utils.ts

@@ -5,6 +5,7 @@ import {
   type WatchContractEventParameters,
   getAccount,
   getChainId,
+  readContract,
   waitForTransactionReceipt,
 } from '@wagmi/core';
 import type { ExtractAbiEvent } from 'abitype';
@@ -255,3 +256,48 @@ export function assertValidAddressByChainId(
   // biome-ignore lint/style/noNonNullAssertion: this type should be narrowed by the above statement but isn't?
   return { chainId, address: addressByChainId[chainId]! };
 }
+
+/**
+ * Check an ERC20's balance for a given asset and
+ *
+ * @public
+ * @async
+ * @param {Config} [config]
+ * @param {Address} [asset]
+ * @param {Address} [owner]
+ * @param {?ReadParams} [params]
+ * @returns {Promise<bigint>} - The erc20 balance
+ */
+export async function getErc20Balance(
+  config: Config,
+  asset: Address,
+  owner: Address,
+  params?: ReadParams,
+) {
+  return await readContract(config, {
+    ...params,
+    functionName: 'balanceOf',
+    address: asset,
+    args: [owner],
+    abi: [
+      {
+        constant: true,
+        inputs: [
+          {
+            name: '_owner',
+            type: 'address',
+          },
+        ],
+        name: 'balanceOf',
+        outputs: [
+          {
+            name: 'balance',
+            type: 'uint256',
+          },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+      },
+    ],
+  });
+}

package/dist/componentInterfaces-BQw7DH-m.cjs

@@ -1,2 +0,0 @@
-"use strict";const e="0xc2c281ec",n="0x53cf8555",t="0x7cc1d5bb",i="0x52b8e45c",c="0x90318111",A="0x7687b0ed",a="0x5fbfaa4e",o="0x0d36a40d",s="0xb8ce7b22",l="0x1392d798",v="0x3d30a22c";exports.AAllowListIncentive=e;exports.ACGDAIncentive=n;exports.AERC20Incentive=t;exports.AERC20VariableCriteriaIncentive=i;exports.AERC20VariableIncentive=c;exports.AEventAction=A;exports.AManagedBudget=a;exports.APointsIncentive=o;exports.ASignerValidator=s;exports.ASimpleAllowList=l;exports.ASimpleDenyList=v;
-//# sourceMappingURL=componentInterfaces-BQw7DH-m.cjs.map

package/dist/componentInterfaces-BQw7DH-m.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"componentInterfaces-BQw7DH-m.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/componentInterfaces-C0vuWQlh.js

@@ -1,15 +0,0 @@
-const e = "0xc2c281ec", n = "0x53cf8555", c = "0x7cc1d5bb", t = "0x52b8e45c", s = "0x90318111", a = "0x7687b0ed", i = "0x5fbfaa4e", o = "0x0d36a40d", A = "0xb8ce7b22", x = "0x1392d798", b = "0x3d30a22c";
-export {
-  a as A,
-  i as a,
-  o as b,
-  c,
-  e as d,
-  n as e,
-  s as f,
-  t as g,
-  A as h,
-  x as i,
-  b as j
-};
-//# sourceMappingURL=componentInterfaces-C0vuWQlh.js.map

package/dist/componentInterfaces-C0vuWQlh.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"componentInterfaces-C0vuWQlh.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/deployments--f75Pthq.cjs

@@ -1,2 +0,0 @@
-"use strict";const e={10:"0x5AA51DCC8F3bdeD3a270613d3C9682EA10062782",8453:"0x5AA51DCC8F3bdeD3a270613d3C9682EA10062782",42161:"0x5AA51DCC8F3bdeD3a270613d3C9682EA10062782",84532:"0x5AA51DCC8F3bdeD3a270613d3C9682EA10062782",11155111:"0x5AA51DCC8F3bdeD3a270613d3C9682EA10062782"},D={10:"0xE2D376c791cAA498b86ebfc3C87121112Fd8Cd5b",8453:"0xE2D376c791cAA498b86ebfc3C87121112Fd8Cd5b",42161:"0xE2D376c791cAA498b86ebfc3C87121112Fd8Cd5b",84532:"0xE2D376c791cAA498b86ebfc3C87121112Fd8Cd5b",11155111:"0xE2D376c791cAA498b86ebfc3C87121112Fd8Cd5b"},C={10:"0x694c04324C2F4D97eBF98FaC633DF54E7A95334f",8453:"0x694c04324C2F4D97eBF98FaC633DF54E7A95334f",42161:"0x694c04324C2F4D97eBF98FaC633DF54E7A95334f",84532:"0x694c04324C2F4D97eBF98FaC633DF54E7A95334f",11155111:"0x694c04324C2F4D97eBF98FaC633DF54E7A95334f"},b={10:"0x2B5E78665C7e79791078dfFE94f04c1d1C42558F",8453:"0x2B5E78665C7e79791078dfFE94f04c1d1C42558F",42161:"0x2B5E78665C7e79791078dfFE94f04c1d1C42558F",84532:"0x2B5E78665C7e79791078dfFE94f04c1d1C42558F",11155111:"0x2B5E78665C7e79791078dfFE94f04c1d1C42558F"},B={10:"0x449094B4fb2A9Bf25dd9876E90ab2310aa386697",8453:"0x449094B4fb2A9Bf25dd9876E90ab2310aa386697",42161:"0x449094B4fb2A9Bf25dd9876E90ab2310aa386697",84532:"0x449094B4fb2A9Bf25dd9876E90ab2310aa386697",11155111:"0x449094B4fb2A9Bf25dd9876E90ab2310aa386697"},A={10:"0x96b23C5B81FEA6Da7f12B70050D4C4f76d3a9D0D",8453:"0x96b23C5B81FEA6Da7f12B70050D4C4f76d3a9D0D",42161:"0x96b23C5B81FEA6Da7f12B70050D4C4f76d3a9D0D",84532:"0x96b23C5B81FEA6Da7f12B70050D4C4f76d3a9D0D",11155111:"0x96b23C5B81FEA6Da7f12B70050D4C4f76d3a9D0D"},F={10:"0x8Db3E5226FD46F14E666954F65557539e7025136",8453:"0x8Db3E5226FD46F14E666954F65557539e7025136",42161:"0x8Db3E5226FD46F14E666954F65557539e7025136",84532:"0x8Db3E5226FD46F14E666954F65557539e7025136",11155111:"0x8Db3E5226FD46F14E666954F65557539e7025136"},a={10:"0x674f6b02e0B1159D61DFFCEe096776fd3B2bb7C1",8453:"0x674f6b02e0B1159D61DFFCEe096776fd3B2bb7C1",42161:"0x674f6b02e0B1159D61DFFCEe096776fd3B2bb7C1",84532:"0x674f6b02e0B1159D61DFFCEe096776fd3B2bb7C1",11155111:"0x674f6b02e0B1159D61DFFCEe096776fd3B2bb7C1"},E={10:"0xC9fB769A6A1e71663E85AE30CCfE97bf67B6d42F",8453:"0xC9fB769A6A1e71663E85AE30CCfE97bf67B6d42F",42161:"0xC9fB769A6A1e71663E85AE30CCfE97bf67B6d42F",84532:"0xC9fB769A6A1e71663E85AE30CCfE97bf67B6d42F",11155111:"0xC9fB769A6A1e71663E85AE30CCfE97bf67B6d42F"},f={10:"0x817aD27DF5a20a995bCD87962A8B32eB60c6c2D9",8453:"0x817aD27DF5a20a995bCD87962A8B32eB60c6c2D9",42161:"0x817aD27DF5a20a995bCD87962A8B32eB60c6c2D9",84532:"0x817aD27DF5a20a995bCD87962A8B32eB60c6c2D9",11155111:"0x817aD27DF5a20a995bCD87962A8B32eB60c6c2D9"},c={10:"0x72D733558473Cb3e9A66B25B99cb9810111f5E11",8453:"0x72D733558473Cb3e9A66B25B99cb9810111f5E11",42161:"0x72D733558473Cb3e9A66B25B99cb9810111f5E11",84532:"0x72D733558473Cb3e9A66B25B99cb9810111f5E11",11155111:"0x72D733558473Cb3e9A66B25B99cb9810111f5E11"},x={10:"0x5aE607016b0a742D0eF3aDD7B3257881bA383CB3",8453:"0x5aE607016b0a742D0eF3aDD7B3257881bA383CB3",42161:"0x5aE607016b0a742D0eF3aDD7B3257881bA383CB3",84532:"0x5aE607016b0a742D0eF3aDD7B3257881bA383CB3",11155111:"0x5aE607016b0a742D0eF3aDD7B3257881bA383CB3"},d={10:"0x5b0eD712b54775584cbB28fe7954e854781AA805",8453:"0x5b0eD712b54775584cbB28fe7954e854781AA805",42161:"0x5b0eD712b54775584cbB28fe7954e854781AA805",84532:"0x5b0eD712b54775584cbB28fe7954e854781AA805",11155111:"0x5b0eD712b54775584cbB28fe7954e854781AA805"};exports.AllowListIncentive=e;exports.BoostCore=D;exports.BoostRegistry=C;exports.CGDAIncentive=b;exports.ERC20Incentive=B;exports.ERC20VariableCriteriaIncentive=A;exports.ERC20VariableIncentive=F;exports.EventAction=a;exports.ManagedBudget=E;exports.PointsIncentive=f;exports.SignerValidator=c;exports.SimpleAllowList=x;exports.SimpleDenyList=d;
-//# sourceMappingURL=deployments--f75Pthq.cjs.map

package/dist/deployments--f75Pthq.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"deployments--f75Pthq.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/deployments-BdPDIh-i.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deployments-BdPDIh-i.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}