@boostxyz/sdk 0.0.0-alpha.3 → 0.0.0-alpha.6

package/src/Incentives/ERC20VariableIncentive.ts

@@ -0,0 +1,368 @@
+import {
+  erc20VariableIncentiveAbi,
+  readErc20VariableIncentiveAsset,
+  readErc20VariableIncentiveClaimed,
+  readErc20VariableIncentiveClaims,
+  readErc20VariableIncentiveCurrentReward,
+  readErc20VariableIncentiveIsClaimable,
+  readErc20VariableIncentiveLimit,
+  readErc20VariableIncentiveOwner,
+  readErc20VariableIncentiveReward,
+  readErc20VariableIncentiveTotalClaimed,
+  simulateErc20VariableIncentiveClaim,
+  simulateErc20VariableIncentiveClawback,
+  writeErc20VariableIncentiveClaim,
+  writeErc20VariableIncentiveClawback,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/incentives/ERC20VariableIncentive.sol/ERC20VariableIncentive.json';
+import type { Address, ContractEventName, Hex } from 'viem';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import {
+  type ClaimPayload,
+  type ERC20VariableIncentivePayload,
+  type GenericLog,
+  type ReadParams,
+  RegistryType,
+  type WriteParams,
+  prepareClaimPayload,
+  prepareERC20VariableIncentivePayload,
+} from '../utils';
+
+export { erc20VariableIncentiveAbi };
+export type { ERC20VariableIncentivePayload };
+
+/**
+ * A generic `viem.Log` event with support for `ERC20VariableIncentive` event types.
+ *
+ * @export
+ * @typedef {ERC20VariableIncentiveLog}
+ * @template {ContractEventName<typeof erc20VariableIncentiveAbi>} [event=ContractEventName<
+ *     typeof erc20VariableIncentiveAbi
+ *   >]
+ */
+export type ERC20VariableIncentiveLog<
+  event extends ContractEventName<
+    typeof erc20VariableIncentiveAbi
+  > = ContractEventName<typeof erc20VariableIncentiveAbi>,
+> = GenericLog<typeof erc20VariableIncentiveAbi, event>;
+
+/**
+ * A simple ERC20 incentive implementation that allows claiming of tokens
+ *
+ * @export
+ * @class ERC20VariableIncentive
+ * @typedef {ERC20VariableIncentive}
+ * @extends {DeployableTarget<ERC20VariableIncentivePayload>}
+ */
+export class ERC20VariableIncentive extends DeployableTarget<
+  ERC20VariableIncentivePayload,
+  typeof erc20VariableIncentiveAbi
+> {
+  public override readonly abi = erc20VariableIncentiveAbi;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Address}
+   */
+  public static override base: Address = import.meta.env
+    .VITE_ERC20_VARIABLE_INCENTIVE_BASE;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.INCENTIVE;
+
+  /**
+   * The owner of the incentive
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'owner'>} [params]
+   * @returns {unknown}
+   */
+  public async owner(
+    params?: ReadParams<typeof erc20VariableIncentiveAbi, 'owner'>,
+  ) {
+    return readErc20VariableIncentiveOwner(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 current reward
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'currentReward'>} [params]
+   * @returns {Promise<bigint>} - The current reward
+   */
+  public async totalClaimed(
+    params?: ReadParams<typeof erc20VariableIncentiveAbi, 'totalClaimed'>,
+  ) {
+    return readErc20VariableIncentiveTotalClaimed(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 current reward
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'currentReward'>} [params]
+   * @returns {Promise<bigint>} - The current reward
+   */
+  public async currentReward(
+    params?: ReadParams<typeof erc20VariableIncentiveAbi, 'currentReward'>,
+  ) {
+    return readErc20VariableIncentiveCurrentReward(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 erc20VariableIncentiveAbi, 'claims'>} [params]
+   * @returns {Promise<bigint>}
+   */
+  public async claims(
+    params?: ReadParams<typeof erc20VariableIncentiveAbi, 'claims'>,
+  ) {
+    return readErc20VariableIncentiveClaims(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),
+    });
+  }
+
+  /**
+   * A mapping of address to claim status
+   *
+   * @public
+   * @async
+   * @param {Address} address
+   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'claimed'>} [params]
+   * @returns {Promise<boolean>}
+   */
+  public async claimed(
+    address: Address,
+    params?: ReadParams<typeof erc20VariableIncentiveAbi, 'claimed'>,
+  ) {
+    return readErc20VariableIncentiveClaimed(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 address of the ERC20-like token
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'asset'>} [params]
+   * @returns {Promise<Address>}
+   */
+  public async asset(
+    params?: ReadParams<typeof erc20VariableIncentiveAbi, 'asset'>,
+  ) {
+    return readErc20VariableIncentiveAsset(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 reward amount issued for each claim
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'reward'>} [params]
+   * @returns {Promise<bigint>}
+   */
+  public async reward(
+    params?: ReadParams<typeof erc20VariableIncentiveAbi, 'reward'>,
+  ) {
+    return readErc20VariableIncentiveReward(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 limit (max claims, or max entries for raffles)
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'limit'>} [params]
+   * @returns {unknown}
+   */
+  public async limit(
+    params?: ReadParams<typeof erc20VariableIncentiveAbi, 'limit'>,
+  ) {
+    return readErc20VariableIncentiveLimit(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 erc20VariableIncentiveAbi, 'claim'>} [params]
+   * @returns {Promise<boolean>} - Returns true if successfully claimed
+   */
+  public async claim(
+    payload: ClaimPayload,
+    params?: WriteParams<typeof erc20VariableIncentiveAbi, 'claim'>,
+  ) {
+    return this.awaitResult(this.claimRaw(payload, params));
+  }
+
+  /**
+   * Claim the incentive
+   *
+   * @public
+   * @async
+   * @param {ClaimPayload} payload
+   * @param {?WriteParams<typeof erc20VariableIncentiveAbi, 'claim'>} [params]
+   * @returns {Promise<boolean>} - Returns true if successfully claimed
+   */
+  public async claimRaw(
+    payload: ClaimPayload,
+    params?: WriteParams<typeof erc20VariableIncentiveAbi, 'claim'>,
+  ) {
+    const { request, result } = await simulateErc20VariableIncentiveClaim(
+      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 writeErc20VariableIncentiveClaim(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * Clawback assets from the incentive
+   *
+   * @public
+   * @async
+   * @param {ClaimPayload} payload
+   * @param {?WriteParams<typeof erc20VariableIncentiveAbi, 'clawback'>} [params]
+   * @returns {Promise<boolean>} -  True if the assets were successfully clawbacked
+   */
+  public async clawback(
+    payload: ClaimPayload,
+    params?: WriteParams<typeof erc20VariableIncentiveAbi, 'clawback'>,
+  ) {
+    return this.awaitResult(this.clawbackRaw(payload, params));
+  }
+
+  /**
+   * Clawback assets from the incentive
+   *
+   * @public
+   * @async
+   * @param {ClaimPayload} payload
+   * @param {?WriteParams<typeof erc20VariableIncentiveAbi, 'clawback'>} [params]
+   * @returns {Promise<boolean>} -  True if the assets were successfully clawbacked
+   */
+  public async clawbackRaw(
+    payload: ClaimPayload,
+    params?: WriteParams<typeof erc20VariableIncentiveAbi, 'clawback'>,
+  ) {
+    const { request, result } = await simulateErc20VariableIncentiveClawback(
+      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 writeErc20VariableIncentiveClawback(
+      this._config,
+      request,
+    );
+    return { hash, result };
+  }
+
+  /**
+   * Check if an incentive is claimable. For the POOL strategy, the `bytes data` portion of the payload ignored. The recipient must not have already claimed the incentive.
+   *
+   * @public
+   * @async
+   * @param {ClaimPayload} payload
+   * @param {?ReadParams<typeof erc20VariableIncentiveAbi, 'isClaimable'>} [params]
+   * @returns {unknown} = True if the incentive is claimable based on the data payload
+   */
+  public async isClaimable(
+    payload: ClaimPayload,
+    params?: ReadParams<typeof erc20VariableIncentiveAbi, 'isClaimable'>,
+  ) {
+    return readErc20VariableIncentiveIsClaimable(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 {?ERC20VariableIncentivePayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: ERC20VariableIncentivePayload,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [payload, options] = this.validateDeploymentConfig(
+      _payload,
+      _options,
+    );
+    return {
+      abi: erc20VariableIncentiveAbi,
+      bytecode: bytecode as Hex,
+      args: [prepareERC20VariableIncentivePayload(payload)],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}

package/src/Incentives/Incentive.test.ts

@@ -0,0 +1,92 @@
+import { zeroAddress } from 'viem';
+import { describe, expect, test } from 'vitest';
+import { defaultOptions } from '../../test/helpers';
+import { StrategyType } from '../utils';
+import {
+  AllowListIncentive,
+  CGDAIncentive,
+  ERC20Incentive,
+  ERC20VariableIncentive,
+  incentiveFromAddress,
+} from './Incentive';
+import { PointsIncentive } from './PointsIncentive';
+
+describe('Incentive', () => {
+  test('can automatically instantiate PointsIncentive given an address', async () => {
+    const incentive = new PointsIncentive(defaultOptions, {
+      venue: zeroAddress,
+      selector: '0xdeadb33f',
+      reward: 1n,
+      limit: 1n,
+    });
+    await incentive.deploy();
+    expect(
+      await incentiveFromAddress(
+        defaultOptions,
+        incentive.assertValidAddress(),
+      ),
+    ).toBeInstanceOf(PointsIncentive);
+  });
+
+  test('can automatically instantiate AllowListIncentive given an address', async () => {
+    const incentive = new AllowListIncentive(defaultOptions, {
+      allowList: zeroAddress,
+      limit: 3n,
+    });
+    await incentive.deploy();
+    expect(
+      await incentiveFromAddress(
+        defaultOptions,
+        incentive.assertValidAddress(),
+      ),
+    ).toBeInstanceOf(AllowListIncentive);
+  });
+
+  test('can automatically instantiate CGDAIncentive given an address', async () => {
+    const incentive = new CGDAIncentive(defaultOptions, {
+      asset: zeroAddress,
+      initialReward: 1n,
+      totalBudget: 10n,
+      rewardBoost: 1n,
+      rewardDecay: 1n,
+    });
+    await incentive.deploy();
+    expect(
+      await incentiveFromAddress(
+        defaultOptions,
+        incentive.assertValidAddress(),
+      ),
+    ).toBeInstanceOf(CGDAIncentive);
+  });
+
+  test('can automatically instantiate ERC20Incentive given an address', async () => {
+    const incentive = new ERC20Incentive(defaultOptions, {
+      asset: zeroAddress,
+      strategy: StrategyType.POOL,
+      reward: 1n,
+      limit: 10n,
+    });
+    await incentive.deploy();
+    expect(
+      await incentiveFromAddress(
+        defaultOptions,
+        incentive.assertValidAddress(),
+      ),
+    ).toBeInstanceOf(ERC20Incentive);
+  });
+
+  test('can automatically instantiate ERC20VariableIncentive given an address', async () => {
+    const incentive = new ERC20VariableIncentive(defaultOptions, {
+      asset: zeroAddress,
+      reward: 1n,
+      limit: 10n,
+    });
+    await incentive.deploy();
+    expect(
+      await incentiveFromAddress(
+        defaultOptions,
+        incentive.assertValidAddress(),
+      ),
+    ).toBeInstanceOf(ERC20VariableIncentive);
+  });
+});

package/src/Incentives/Incentive.ts

@@ -0,0 +1,85 @@
+import { aIncentiveAbi } from '@boostxyz/evm';
+import {
+  AAllowListIncentive,
+  ACGDAIncentive,
+  AERC20Incentive,
+  AERC20VariableIncentive,
+  APointsIncentive,
+} from '@boostxyz/evm/deploys/componentInterfaces.json';
+import { readContract } from '@wagmi/core';
+import type { Address, Hex } from 'viem';
+import type { DeployableOptions } from '../Deployable/Deployable';
+import { InvalidComponentInterfaceError } from '../errors';
+import { AllowListIncentive } from './AllowListIncentive';
+import { CGDAIncentive } from './CGDAIncentive';
+import { ERC20Incentive } from './ERC20Incentive';
+import { ERC20VariableIncentive } from './ERC20VariableIncentive';
+// import { ERC1155Incentive } from './ERC1155Incentive';
+import { PointsIncentive } from './PointsIncentive';
+
+export {
+  AllowListIncentive,
+  CGDAIncentive,
+  // ERC1155Incentive,
+  ERC20Incentive,
+  PointsIncentive,
+  ERC20VariableIncentive,
+};
+
+/**
+ * A union type representing all valid protocol Incentive implementations
+ *
+ * @export
+ * @typedef {Incentive}
+ */
+export type Incentive =
+  | AllowListIncentive
+  | CGDAIncentive
+  | ERC20Incentive
+  // | ERC1155Incentive
+  | PointsIncentive
+  | ERC20VariableIncentive;
+
+/**
+ * A map of Incentive component interfaces to their constructors.
+ *
+ * @type {{ "0xc5b24b8e": typeof PointsIncentive; "0x8c901437": typeof ERC20Incentive; "0x0a466e6f": typeof AllowListIncentive; "0xa39e44d9": typeof CGDAIncentive; "0x6060409d": typeof ERC20VariableIncentive }}
+ */
+export const IncentiveByComponentInterface = {
+  [APointsIncentive as Hex]: PointsIncentive,
+  [AERC20Incentive as Hex]: ERC20Incentive,
+  // TODO: figure out why evm generates bad bytes4 here
+  ['0x0a466e6f']: AllowListIncentive,
+  // [APointsIncentive as Hex]: ERC1155Incentive,
+  [ACGDAIncentive as Hex]: CGDAIncentive,
+  [AERC20VariableIncentive as Hex]: ERC20VariableIncentive,
+};
+
+/**
+ * A function that will read a contract's component interface using `getComponentInterface` and return the correct instantiated instance.
+ *
+ * @export
+ * @async
+ * @param {DeployableOptions} options
+ * @param {Address} address
+ * @returns {unknown}
+ * @throws {@link InvalidComponentInterfaceError}
+ */
+export async function incentiveFromAddress(
+  options: DeployableOptions,
+  address: Address,
+) {
+  const interfaceId = (await readContract(options.config, {
+    abi: aIncentiveAbi,
+    functionName: 'getComponentInterface',
+    address,
+  })) as keyof typeof IncentiveByComponentInterface;
+  const Ctor = IncentiveByComponentInterface[interfaceId];
+  if (!Ctor) {
+    throw new InvalidComponentInterfaceError(
+      Object.keys(IncentiveByComponentInterface) as Hex[],
+      interfaceId as Hex,
+    );
+  }
+  return new Ctor(options, address);
+}

package/src/Incentives/PointsIncentive.test.ts

@@ -0,0 +1,142 @@
+import { readPointsBalanceOf, writePointsGrantRoles } from '@boostxyz/evm';
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { signMessage } from '@wagmi/core';
+import { isAddress, pad, parseEther, zeroAddress } from 'viem';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import type { MockPoints } from '../../test/MockPoints';
+import { accounts } from '../../test/accounts';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+  freshBoost,
+  freshPoints,
+} from '../../test/helpers';
+import { bytes4, prepareSignerValidatorClaimDataPayload } from '../utils';
+import { PointsIncentive } from './PointsIncentive';
+
+let fixtures: Fixtures, points: MockPoints;
+
+describe('PointsIncentive', () => {
+  beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures);
+  });
+
+  beforeEach(async () => {
+    points = await loadFixture(freshPoints);
+  });
+
+  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 pointsIncentive = new fixtures.bases.PointsIncentive(defaultOptions, {
+      venue: points.assertValidAddress(),
+      selector: bytes4('issue(address,uint256)'),
+      reward: 1n,
+      limit: 10n,
+    });
+    const boost = await freshBoost(fixtures, {
+      incentives: [pointsIncentive],
+    });
+
+    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 writePointsGrantRoles(defaultOptions.config, {
+      address: points.assertValidAddress(),
+      args: [pointsIncentive.assertValidAddress(), 2n],
+      account: defaultOptions.account,
+    });
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      { value: parseEther('0.000075') },
+    );
+    expect(
+      await readPointsBalanceOf(defaultOptions.config, {
+        address: points.assertValidAddress(),
+        args: [defaultOptions.account.address],
+      }),
+    ).toBe(1n);
+  });
+
+  test('cannot claim twice', async () => {
+    const reward = 1n;
+    // 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 = new fixtures.bases.PointsIncentive(defaultOptions, {
+      venue: points.assertValidAddress(),
+      selector: bytes4('issue(address,uint256)'),
+      reward,
+      limit: 10n,
+    });
+    const boost = await freshBoost(fixtures, {
+      incentives: [pointsIncentive],
+    });
+
+    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 writePointsGrantRoles(defaultOptions.config, {
+      address: points.assertValidAddress(),
+      args: [pointsIncentive.assertValidAddress(), 2n],
+      account: defaultOptions.account,
+    });
+    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);
+    }
+  });
+});