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

package/src/Incentives/CGDAIncentive.ts

@@ -0,0 +1,364 @@
+import {
+  cgdaIncentiveAbi,
+  readCgdaIncentiveAsset,
+  readCgdaIncentiveCgdaParams,
+  readCgdaIncentiveClaimed,
+  readCgdaIncentiveClaims,
+  readCgdaIncentiveCurrentReward,
+  readCgdaIncentiveIsClaimable,
+  readCgdaIncentiveOwner,
+  readCgdaIncentiveReward,
+  readCgdaIncentiveTotalBudget,
+  simulateCgdaIncentiveClaim,
+  simulateCgdaIncentiveClawback,
+  writeCgdaIncentiveClaim,
+  writeCgdaIncentiveClawback,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/incentives/CGDAIncentive.sol/CGDAIncentive.json';
+import type { Address, ContractEventName, Hex } from 'viem';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import {
+  type CGDAIncentivePayload,
+  type CGDAParameters,
+  type ClaimPayload,
+  type GenericLog,
+  type ReadParams,
+  RegistryType,
+  type WriteParams,
+  prepareCGDAIncentivePayload,
+  prepareClaimPayload,
+} from '../utils';
+
+export { cgdaIncentiveAbi };
+export type { CGDAIncentivePayload };
+
+/**
+ * A generic `viem.Log` event with support for `CGDAIncentive` event types.
+ *
+ * @export
+ * @typedef {CGDAIncentiveLog}
+ * @template {ContractEventName<typeof cgdaIncentiveAbi>} [event=ContractEventName<
+ *     typeof cgdaIncentiveAbi
+ *   >]
+ */
+export type CGDAIncentiveLog<
+  event extends ContractEventName<typeof cgdaIncentiveAbi> = ContractEventName<
+    typeof cgdaIncentiveAbi
+  >,
+> = GenericLog<typeof cgdaIncentiveAbi, event>;
+
+/**
+ * Continuous Gradual Dutch Auction Incentive.
+ * An CGDA incentive implementation with reward amounts adjusting dynamically based on claim volume.
+ *
+ * @export
+ * @class CGDAIncentive
+ * @typedef {CGDAIncentive}
+ * @extends {DeployableTarget<CGDAIncentivePayload>}
+ */
+export class CGDAIncentive extends DeployableTarget<
+  CGDAIncentivePayload,
+  typeof cgdaIncentiveAbi
+> {
+  public override readonly abi = cgdaIncentiveAbi;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Address}
+   */
+  public static override base: Address = import.meta.env
+    .VITE_CGDA_INCENTIVE_BASE;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.INCENTIVE;
+
+  /**
+   * The incentive's owner.
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof cgdaIncentiveAbi, 'owner'>} [params]
+   * @returns {unknown}
+   */
+  public async owner(params?: ReadParams<typeof cgdaIncentiveAbi, 'owner'>) {
+    return readCgdaIncentiveOwner(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 cgdaIncentiveAbi, 'claims'>} [params]
+   * @returns {Promise<bigint>}
+   */
+  public async claims(params?: ReadParams<typeof cgdaIncentiveAbi, 'claims'>) {
+    return readCgdaIncentiveClaims(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 cgdaIncentiveAbi, 'reward'>) {
+    return readCgdaIncentiveReward(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 cgdaIncentiveAbi, 'claimed'>} [params]
+   * @returns {Promise<boolean>}
+   */
+  public async claimed(
+    address: Address,
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'claimed'>,
+  ) {
+    return readCgdaIncentiveClaimed(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 CGDA-like token used for the incentive
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof cgdaIncentiveAbi, 'asset'>} [params]
+   * @returns {unknown}
+   */
+  public async asset(params?: ReadParams<typeof cgdaIncentiveAbi, 'asset'>) {
+    return readCgdaIncentiveAsset(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),
+    });
+  }
+
+  /**
+   * The configuration parameters for the CGDAIncentive
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof cgdaIncentiveAbi, 'cgdaParams'>} [params]
+   * @returns {Promise<CGDAParameters>}
+   */
+  public async cgdaParams(
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'cgdaParams'>,
+  ): Promise<CGDAParameters> {
+    const [rewardDecay, rewardBoost, lastClaimTime, currentReward] =
+      await readCgdaIncentiveCgdaParams(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 {
+      rewardDecay,
+      rewardBoost,
+      lastClaimTime,
+      currentReward,
+    };
+  }
+
+  /**
+   * The total budget of the incentive
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof cgdaIncentiveAbi, 'totalBudget'>} [params]
+   * @returns {Promise<bigint>}
+   */
+  public async totalBudget(
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'totalBudget'>,
+  ) {
+    return readCgdaIncentiveTotalBudget(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 the incentive
+   *
+   * @public
+   * @async
+   * @param {ClaimPayload} payload
+   * @param {?WriteParams<typeof cgdaIncentiveAbi, 'claim'>} [params]
+   * @returns {Promise<boolean>} - Returns true if successfully claimed
+   */
+  public async claim(
+    payload: ClaimPayload,
+    params?: WriteParams<typeof cgdaIncentiveAbi, 'claim'>,
+  ) {
+    return this.awaitResult(this.claimRaw(payload, params));
+  }
+
+  /**
+   * Claim the incentive
+   *
+   * @public
+   * @async
+   * @param {ClaimPayload} payload
+   * @param {?WriteParams<typeof cgdaIncentiveAbi, 'claim'>} [params]
+   * @returns {Promise<boolean>} - Returns true if successfully claimed
+   */
+  public async claimRaw(
+    payload: ClaimPayload,
+    params?: WriteParams<typeof cgdaIncentiveAbi, 'claim'>,
+  ) {
+    const { request, result } = await simulateCgdaIncentiveClaim(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 writeCgdaIncentiveClaim(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * Clawback assets from the incentive
+   *
+   * @public
+   * @async
+   * @param {ClaimPayload} payload
+   * @param {?WriteParams<typeof cgdaIncentiveAbi, 'clawback'>} [params]
+   * @returns {Promise<boolean>} -  True if the assets were successfully clawbacked
+   */
+  public async clawback(
+    payload: ClaimPayload,
+    params?: WriteParams<typeof cgdaIncentiveAbi, 'clawback'>,
+  ) {
+    return this.awaitResult(this.clawbackRaw(payload, params));
+  }
+
+  /**
+   * Clawback assets from the incentive
+   *
+   * @public
+   * @async
+   * @param {ClaimPayload} payload
+   * @param {?WriteParams<typeof cgdaIncentiveAbi, 'clawback'>} [params]
+   * @returns {Promise<boolean>} -  True if the assets were successfully clawbacked
+   */
+  public async clawbackRaw(
+    payload: ClaimPayload,
+    params?: WriteParams<typeof cgdaIncentiveAbi, 'clawback'>,
+  ) {
+    const { request, result } = await simulateCgdaIncentiveClawback(
+      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 writeCgdaIncentiveClawback(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * Check if an incentive is claimable
+   *
+   * @public
+   * @async
+   * @param {ClaimPayload} payload
+   * @param {?ReadParams<typeof cgdaIncentiveAbi, 'isClaimable'>} [params]
+   * @returns {Promise<boolean>} - True if the incentive is claimable based on the data payload
+   */
+  public async isClaimable(
+    payload: ClaimPayload,
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'isClaimable'>,
+  ) {
+    return readCgdaIncentiveIsClaimable(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),
+    });
+  }
+
+  /**
+   * 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.
+   * For example, if there is one claim in the first hour, then no claims for three hours, the claimable reward would be `initialReward - rewardDecay + (rewardBoost * 3)`
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof cgdaIncentiveAbi, 'currentReward'>} [params]
+   * @returns {Promise<bigint>} - The current reward
+   */
+  public async currentReward(
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'currentReward'>,
+  ) {
+    return readCgdaIncentiveCurrentReward(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),
+    });
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @param {?CGDAIncentivePayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: CGDAIncentivePayload,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [payload, options] = this.validateDeploymentConfig(
+      _payload,
+      _options,
+    );
+    return {
+      abi: cgdaIncentiveAbi,
+      bytecode: bytecode as Hex,
+      args: [prepareCGDAIncentivePayload(payload)],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}

package/src/Incentives/ERC1155Incentive.test.ts

@@ -0,0 +1,98 @@
+import { readMockErc1155BalanceOf } from '@boostxyz/evm';
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { signMessage } from '@wagmi/core';
+import {
+  encodePacked,
+  isAddress,
+  keccak256,
+  pad,
+  parseEther,
+  zeroAddress,
+  zeroHash,
+} 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 { ERC1155Incentive, ERC1155StrategyType } from './ERC1155Incentive';
+
+const BOOST_CORE_CLAIM_FEE = parseEther('0.000075');
+
+let fixtures: Fixtures, budgets: BudgetFixtures;
+
+describe.skip('ERC1155Incentive', () => {
+  beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures);
+  });
+
+  beforeEach(async () => {
+    budgets = await loadFixture(fundBudget(defaultOptions, fixtures));
+  });
+
+  test('can successfully be deployed', async () => {
+    const action = new ERC1155Incentive(defaultOptions, {
+      asset: zeroAddress,
+      strategy: ERC1155StrategyType.MINT,
+      tokenId: 0n,
+      limit: 10n,
+      extraData: '0x',
+    });
+    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
+      trustedSigner = accounts.at(0)!;
+    const erc1155Incentive = new fixtures.bases.ERC1155Incentive(
+      defaultOptions,
+      {
+        asset: budgets.erc1155.assertValidAddress(),
+        strategy: ERC1155StrategyType.POOL,
+        tokenId: 1n,
+        limit: 1n,
+        extraData: zeroHash,
+      },
+    );
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc1155Incentive],
+    });
+
+    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: BOOST_CORE_CLAIM_FEE },
+    );
+    expect(
+      await readMockErc1155BalanceOf(defaultOptions.config, {
+        address: budgets.erc1155.assertValidAddress(),
+        args: [defaultOptions.account.address, 1n],
+      }),
+    ).toBe(1n);
+  });
+});