@boostxyz/sdk 0.0.0-alpha.5 → 0.0.0-alpha.7

package/src/Incentives/AllowListIncentive.test.ts

@@ -0,0 +1,146 @@
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { isAddress, pad, parseEther, zeroAddress } from 'viem';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { accounts } from '../../test/accounts';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+  freshBoost,
+} from '../../test/helpers';
+import { LIST_MANAGER_ROLE } from '../AllowLists/SimpleAllowList';
+import { prepareSignerValidatorClaimDataPayload } from '../utils';
+import { PointsIncentive } from './PointsIncentive';
+
+let fixtures: Fixtures;
+
+function freshAllowList(fixtures: Fixtures) {
+  return function freshAllowList() {
+    return fixtures.registry.clone(
+      crypto.randomUUID(),
+      new fixtures.bases.SimpleAllowList(defaultOptions, {
+        owner: defaultOptions.account.address,
+        allowed: [],
+      }),
+    );
+  };
+}
+
+describe('AllowListIncentive', () => {
+  beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures);
+  });
+
+  test('can successfully be deployed', async () => {
+    const action = new PointsIncentive(defaultOptions, {
+      venue: zeroAddress,
+      selector: '0xdeadb33f',
+      reward: 1n,
+      limit: 1n,
+    });
+    await action.deploy();
+    expect(isAddress(action.assertValidAddress())).toBe(true);
+  });
+
+  test('can claim', 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: 3n,
+      },
+    );
+    const boost = await freshBoost(fixtures, {
+      incentives: [allowListIncentive],
+    });
+    await allowList.grantRoles(
+      allowListIncentive.assertValidAddress(),
+      LIST_MANAGER_ROLE,
+    );
+
+    const claimant = trustedSigner.account;
+    const incentiveData = pad('0xdef456232173821931823712381232131391321934');
+    console.log(claimant);
+
+    const incentiveQuantity = 1;
+    const claimDataPayload = await prepareSignerValidatorClaimDataPayload({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      validator: boost.validator.assertValidAddress(),
+      incentiveQuantity,
+      claimant,
+      boostId: boost.id,
+    });
+
+    //await boost.validator.setValidatorCaller(boost.assertValidAddress());
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      { value: parseEther('0.000075'), account: trustedSigner.privateKey },
+    );
+    expect(await allowList.isAllowed(trustedSigner.account)).toBe(true);
+  });
+
+  test('cannot claim twice', 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: 3n,
+      },
+    );
+    const boost = await freshBoost(fixtures, {
+      incentives: [allowListIncentive],
+    });
+    await allowList.grantRoles(
+      allowListIncentive.assertValidAddress(),
+      LIST_MANAGER_ROLE,
+    );
+    const incentiveQuantity = 1;
+    const claimant = trustedSigner.account;
+    const incentiveData = pad('0xdef456232173821931823712381232131391321934');
+    console.log(claimant);
+
+    const claimDataPayload = await prepareSignerValidatorClaimDataPayload({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      validator: boost.validator.assertValidAddress(),
+      incentiveQuantity,
+      claimant,
+      boostId: boost.id,
+    });
+
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      { value: parseEther('0.000075'), account: trustedSigner.privateKey },
+    );
+    try {
+      await fixtures.core.claimIncentive(
+        boost.id,
+        0n,
+        referrer,
+        claimDataPayload,
+        { value: parseEther('0.000075'), account: trustedSigner.privateKey },
+      );
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+    }
+  });
+});

package/src/Incentives/AllowListIncentive.ts

@@ -0,0 +1,290 @@
+import {
+  allowListIncentiveAbi,
+  readAllowListIncentiveAllowList,
+  readAllowListIncentiveClaimed,
+  readAllowListIncentiveClaims,
+  readAllowListIncentiveIsClaimable,
+  readAllowListIncentiveLimit,
+  readAllowListIncentiveOwner,
+  readAllowListIncentiveReward,
+  simulateAllowListIncentiveClaim,
+  writeAllowListIncentiveClaim,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/incentives/AllowListIncentive.sol/AllowListIncentive.json';
+import type { Address, ContractEventName, Hex } from 'viem';
+import { SimpleAllowList } from '../AllowLists/AllowList';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import {
+  type AllowListIncentivePayload,
+  type ClaimPayload,
+  type GenericLog,
+  type ReadParams,
+  RegistryType,
+  type WriteParams,
+  prepareAllowListIncentivePayload,
+  prepareClaimPayload,
+} from '../utils';
+
+export { allowListIncentiveAbi };
+export type { AllowListIncentivePayload };
+
+/**
+ * A generic `viem.Log` event with support for `AllowListIncentive` event types.
+ *
+ * @export
+ * @typedef {AllowListIncentiveLog}
+ * @template {ContractEventName<
+ *     typeof allowListIncentiveAbi
+ *   >} [event=ContractEventName<typeof allowListIncentiveAbi>]
+ */
+export type AllowListIncentiveLog<
+  event extends ContractEventName<
+    typeof allowListIncentiveAbi
+  > = ContractEventName<typeof allowListIncentiveAbi>,
+> = GenericLog<typeof allowListIncentiveAbi, event>;
+
+/**
+ * An incentive implementation that grants the claimer a slot on an {SimpleAllowList}
+ * In order for any claim to be successful:
+ * - The claimer must not already be on the allow list; and
+ * - The maximum number of claims must not have been reached; and
+ * - This contract must be authorized to modify the allow list
+ *
+ * @export
+ * @class AllowListIncentive
+ * @typedef {AllowListIncentive}
+ * @extends {DeployableTarget<AllowListIncentivePayload>}
+ */
+export class AllowListIncentive extends DeployableTarget<
+  AllowListIncentivePayload,
+  typeof allowListIncentiveAbi
+> {
+  public override readonly abi = allowListIncentiveAbi;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Address}
+   */
+  public static override base: Address = import.meta.env
+    .VITE_ALLOWLIST_INCENTIVE_BASE;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.INCENTIVE;
+
+  /**
+   * The owner of the allowList
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof allowListIncentiveAbi, 'owner'>} [params]
+   * @returns {unknown}
+   */
+  public async owner(
+    params?: ReadParams<typeof allowListIncentiveAbi, 'owner'>,
+  ) {
+    return readAllowListIncentiveOwner(this._config, {
+      address: this.assertValidAddress(),
+      args: [],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * The number of claims that have been made
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof allowListIncentiveAbi, 'claims'>} [params]
+   * @returns {Promise<bigint>}
+   */
+  public async claims(
+    params?: ReadParams<typeof allowListIncentiveAbi, 'claims'>,
+  ) {
+    return readAllowListIncentiveClaims(this._config, {
+      address: this.assertValidAddress(),
+      args: [],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * The reward amount issued for each claim
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof allowListIncentiveAbi, 'reward'>} [params]
+   * @returns {Promise<bigint>}
+   */
+  public async reward(
+    params?: ReadParams<typeof allowListIncentiveAbi, 'reward'>,
+  ) {
+    return readAllowListIncentiveReward(this._config, {
+      address: this.assertValidAddress(),
+      args: [],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Get the claim status for a user
+   *
+   * @public
+   * @async
+   * @param {Address} address
+   * @param {?ReadParams<typeof allowListIncentiveAbi, 'claimed'>} [params]
+   * @returns {Promise<boolean>}
+   */
+  public async claimed(
+    address: Address,
+    params?: ReadParams<typeof allowListIncentiveAbi, 'claimed'>,
+  ) {
+    return readAllowListIncentiveClaimed(this._config, {
+      address: this.assertValidAddress(),
+      args: [address],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * The {@link SimpleAllowList} contract
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof allowListIncentiveAbi, 'allowList'>} [params]
+   * @returns {Promise<SimpleAllowList>}
+   */
+  public async allowList(
+    params?: ReadParams<typeof allowListIncentiveAbi, 'allowList'>,
+  ): Promise<SimpleAllowList> {
+    const address = await readAllowListIncentiveAllowList(this._config, {
+      address: this.assertValidAddress(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+    return new SimpleAllowList(
+      { config: this._config, account: this._account },
+      address,
+    );
+  }
+
+  /**
+   * The maximum number of claims that can be made (one per address)
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof allowListIncentiveAbi, 'limit'>} [params]
+   * @returns {unknown}
+   */
+  public async limit(
+    params?: ReadParams<typeof allowListIncentiveAbi, 'limit'>,
+  ) {
+    return readAllowListIncentiveLimit(this._config, {
+      address: this.assertValidAddress(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Claim a slot on the {@link SimpleAllowList}
+   *
+   * @public
+   * @async
+   * @param {Pick<ClaimPayload, 'target'>} payload
+   * @param {?WriteParams<typeof allowListIncentiveAbi, 'claim'>} [params]
+   * @returns {Promise<true>} - return true if successful, otherwise revert
+   */
+  public async claim(
+    payload: Pick<ClaimPayload, 'target'>,
+    params?: WriteParams<typeof allowListIncentiveAbi, 'claim'>,
+  ) {
+    return this.awaitResult(this.claimRaw(payload, params));
+  }
+
+  /**
+   * Claim a slot on the {@link SimpleAllowList}
+   *
+   * @public
+   * @async
+   * @param {Pick<ClaimPayload, 'target'>} payload
+   * @param {?WriteParams<typeof allowListIncentiveAbi, 'claim'>} [params]
+   * @returns {Promise<true>} - return true if successful, otherwise revert
+   */
+  public async claimRaw(
+    payload: Pick<ClaimPayload, 'target'>,
+    params?: WriteParams<typeof allowListIncentiveAbi, 'claim'>,
+  ) {
+    const { request, result } = await simulateAllowListIncentiveClaim(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [prepareClaimPayload(payload)],
+        ...this.optionallyAttachAccount(),
+        // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+        ...(params as any),
+      },
+    );
+    const hash = await writeAllowListIncentiveClaim(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * Check if an incentive is claimable
+   *
+   * @public
+   * @async
+   * @param {Pick<ClaimPayload, 'target'>} payload
+   * @param {?ReadParams<typeof allowListIncentiveAbi, 'isClaimable'>} [params]
+   * @returns {Promise<boolean>} - True if the incentive is claimable based on the data payload
+   */
+  public async isClaimable(
+    payload: Pick<ClaimPayload, 'target'>,
+    params?: ReadParams<typeof allowListIncentiveAbi, 'isClaimable'>,
+  ) {
+    return readAllowListIncentiveIsClaimable(this._config, {
+      address: this.assertValidAddress(),
+      args: [prepareClaimPayload(payload)],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @param {?AllowListIncentivePayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: AllowListIncentivePayload,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [payload, options] = this.validateDeploymentConfig(
+      _payload,
+      _options,
+    );
+    return {
+      abi: allowListIncentiveAbi,
+      bytecode: bytecode as Hex,
+      args: [prepareAllowListIncentivePayload(payload)],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}

package/src/Incentives/CGDAIncentive.test.ts

@@ -0,0 +1,136 @@
+import { readMockErc20BalanceOf } from '@boostxyz/evm';
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { signMessage } from '@wagmi/core';
+import { encodePacked, isAddress, keccak256, pad, parseEther } from 'viem';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import { accounts } from '../../test/accounts';
+import {
+  type BudgetFixtures,
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+  freshBoost,
+  fundBudget,
+} from '../../test/helpers';
+import { prepareSignerValidatorClaimDataPayload } from '../utils';
+import { CGDAIncentive } from './CGDAIncentive';
+
+let fixtures: Fixtures, budgets: BudgetFixtures;
+
+describe('CGDAIncentive', () => {
+  beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures);
+  });
+
+  beforeEach(async () => {
+    budgets = await loadFixture(fundBudget(defaultOptions, fixtures));
+  });
+
+  test('can successfully be deployed', async () => {
+    const action = new CGDAIncentive(defaultOptions, {
+      asset: budgets.erc20.assertValidAddress(),
+      initialReward: 1n,
+      totalBudget: 10n,
+      rewardBoost: 1n,
+      rewardDecay: 1n,
+    });
+    await action.deploy();
+    expect(isAddress(action.assertValidAddress())).toBe(true);
+  });
+
+  test('can claim', 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 = new fixtures.bases.CGDAIncentive(defaultOptions, {
+      asset: budgets.erc20.assertValidAddress(),
+      initialReward: 1n,
+      totalBudget: 10n,
+      rewardBoost: 1n,
+      rewardDecay: 1n,
+    });
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20Incentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveData = pad('0xdef456232173821931823712381232131391321934');
+
+    const incentiveQuantity = 1;
+    const claimDataPayload = await prepareSignerValidatorClaimDataPayload({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      validator: boost.validator.assertValidAddress(),
+      incentiveQuantity,
+      claimant,
+      boostId: boost.id,
+    });
+
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      { value: parseEther('0.000075') },
+    );
+    expect(
+      await readMockErc20BalanceOf(defaultOptions.config, {
+        address: budgets.erc20.assertValidAddress(),
+        args: [defaultOptions.account.address],
+      }),
+    ).toBe(1n);
+  });
+
+  test('cannot claim twice', 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 = new fixtures.bases.CGDAIncentive(defaultOptions, {
+      asset: budgets.erc20.assertValidAddress(),
+      initialReward: 1n,
+      totalBudget: 10n,
+      rewardBoost: 1n,
+      rewardDecay: 1n,
+    });
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20Incentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveData = pad('0xdef456232173821931823712381232131391321934');
+    const incentiveQuantity = 1;
+    const claimDataPayload = await prepareSignerValidatorClaimDataPayload({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      validator: boost.validator.assertValidAddress(),
+      incentiveQuantity,
+      claimant,
+      boostId: boost.id,
+    });
+
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      { value: parseEther('0.000075') },
+    );
+    try {
+      await fixtures.core.claimIncentive(
+        boost.id,
+        0n,
+        referrer,
+        claimDataPayload,
+        { value: parseEther('0.000075') },
+      );
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+    }
+  });
+});