@boostxyz/sdk 0.0.0-alpha.2 → 0.0.0-alpha.21

package/src/Incentives/PointsIncentive.test.ts

@@ -0,0 +1,138 @@
+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 {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+  freshBoost,
+  freshPoints,
+} from "@boostxyz/test/helpers";
+import { bytes4 } from "../utils";
+import { PointsIncentive } from "./PointsIncentive";
+
+let fixtures: Fixtures, points: MockPoints;
+
+describe("PointsIncentive", () => {
+  beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
+  });
+
+  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 = fixtures.core.PointsIncentive({
+      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 boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      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
+    );
+    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 = fixtures.core.PointsIncentive({
+      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 boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      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);
+    }
+  });
+});

package/src/Incentives/PointsIncentive.ts

@@ -0,0 +1,367 @@
+import {
+  pointsIncentiveAbi,
+  readPointsIncentiveClaimed,
+  readPointsIncentiveClaims,
+  readPointsIncentiveCurrentReward,
+  readPointsIncentiveIsClaimable,
+  readPointsIncentiveLimit,
+  readPointsIncentiveReward,
+  readPointsIncentiveSelector,
+  readPointsIncentiveVenue,
+  simulatePointsIncentiveClaim,
+  writePointsIncentiveClaim,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/incentives/PointsIncentive.sol/PointsIncentive.json';
+import {
+  type Address,
+  type ContractEventName,
+  type Hex,
+  encodeAbiParameters,
+} from 'viem';
+import { PointsIncentive as PointsIncentiveBases } from '../../dist/deployments.json';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import { type ClaimPayload, prepareClaimPayload } from '../claiming';
+import {
+  type GenericLog,
+  type ReadParams,
+  RegistryType,
+  type WriteParams,
+} from '../utils';
+
+export { pointsIncentiveAbi };
+
+/**
+ * The object representation of a `PointsIncentive.InitPayload`
+ *
+ * @export
+ * @interface PointsIncentivePayload
+ * @typedef {PointsIncentivePayload}
+ */
+export interface PointsIncentivePayload {
+  /**
+   * The address of the points contract
+   *
+   * @type {Address}
+   */
+  venue: Address;
+  /**
+   * The selector for the issuance function on the points contract
+   *
+   * @type {Hex}
+   */
+  selector: Hex;
+  /**
+   * The reward amount issued for each claim
+   *
+   * @type {bigint}
+   */
+  reward: bigint;
+  /**
+   *  The maximum number of claims that can be made (one per address)
+   *
+   * @type {bigint}
+   */
+  limit: bigint;
+}
+
+/**
+ * A generic `viem.Log` event with support for `PointsIncentive` event types.
+ *
+ * @export
+ * @typedef {PointsIncentiveLog}
+ * @template {ContractEventName<
+ *     typeof pointsIncentiveAbi
+ *   >} [event=ContractEventName<typeof pointsIncentiveAbi>]
+ */
+export type PointsIncentiveLog<
+  event extends ContractEventName<
+    typeof pointsIncentiveAbi
+  > = ContractEventName<typeof pointsIncentiveAbi>,
+> = GenericLog<typeof pointsIncentiveAbi, event>;
+
+/**
+ * A simple on-chain points incentive implementation that allows claiming of soulbound tokens.
+ *
+ * In order for any claim to be successful:
+ * - The claimer must not have already claimed the incentive; and
+ * - The maximum number of claims must not have been reached; and
+ * - This contract must be authorized to operate the points contract's issuance function
+ *
+ * @export
+ * @class PointsIncentive
+ * @typedef {PointsIncentive}
+ * @extends {DeployableTarget<PointsIncentivePayload>}
+ */
+export class PointsIncentive extends DeployableTarget<
+  PointsIncentivePayload,
+  typeof pointsIncentiveAbi
+> {
+  public override readonly abi = pointsIncentiveAbi;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Record<number, Address>}
+   */
+  public static override bases: Record<number, Address> = {
+    ...(PointsIncentiveBases as Record<number, Address>),
+  };
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.INCENTIVE;
+
+  /**
+   * The number of claims that have been made
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>}
+   */
+  public async claims(
+    params?: ReadParams<typeof pointsIncentiveAbi, 'claims'>,
+  ) {
+    return await readPointsIncentiveClaims(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} [params]
+   * @returns {Promise<bigint>} - The current reward
+   */
+  public async currentReward(
+    params?: ReadParams<typeof pointsIncentiveAbi, 'currentReward'>,
+  ) {
+    return await readPointsIncentiveCurrentReward(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} [params]
+   * @returns {Promise<bigint>} The reward amount issued for each claim
+   */
+  public async reward(
+    params?: ReadParams<typeof pointsIncentiveAbi, 'reward'>,
+  ) {
+    return await readPointsIncentiveReward(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} [params]
+   * @returns {Promise<boolean>}
+   */
+  public async claimed(
+    address: Address,
+    params?: ReadParams<typeof pointsIncentiveAbi, 'claimed'>,
+  ) {
+    return await readPointsIncentiveClaimed(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 points contract
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Address>}
+   */
+  public async venue(params?: ReadParams<typeof pointsIncentiveAbi, 'venue'>) {
+    return await readPointsIncentiveVenue(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 maximum number of claims that can be made (one per address)
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>}
+   */
+  public async limit(params?: ReadParams<typeof pointsIncentiveAbi, 'limit'>) {
+    return await readPointsIncentiveLimit(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 selector for the issuance function on the points contract
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Hex>}
+   */
+  public async selector(
+    params?: ReadParams<typeof pointsIncentiveAbi, 'selector'>,
+  ) {
+    return await readPointsIncentiveSelector(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} [params]
+   * @returns {Promise<boolean>} -  True if the incentive was successfully claimed
+   */
+  protected async claim(
+    payload: ClaimPayload,
+    params?: WriteParams<typeof pointsIncentiveAbi, 'claim'>,
+  ) {
+    return await this.awaitResult(this.claimRaw(payload, params));
+  }
+
+  /**
+   * Claim the incentive
+   *
+   * @public
+   * @async
+   * @param {ClaimPayload} payload
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} -  True if the incentive was successfully claimed
+   */
+  protected async claimRaw(
+    payload: ClaimPayload,
+    params?: WriteParams<typeof pointsIncentiveAbi, 'claim'>,
+  ) {
+    const { request, result } = await simulatePointsIncentiveClaim(
+      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 writePointsIncentiveClaim(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} [params]
+   * @returns {Promise<boolean>} -  True if the incentive is claimable based on the data payload
+   */
+  public async isClaimable(
+    payload: ClaimPayload,
+    params?: ReadParams<typeof pointsIncentiveAbi, 'isClaimable'>,
+  ) {
+    return await readPointsIncentiveIsClaimable(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 {?PointsIncentivePayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: PointsIncentivePayload,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [payload, options] = this.validateDeploymentConfig(
+      _payload,
+      _options,
+    );
+    return {
+      abi: pointsIncentiveAbi,
+      bytecode: bytecode as Hex,
+      args: [preparePointsIncentivePayload(payload)],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}
+
+/**
+ * Given a {@link PointsIncentivePayload}, properly encode a `PointsIncentive.InitPayload` for use with {@link PointsIncentive} initialization.
+ *
+ * @param {PointsIncentivePayload} param0
+ * @param {Address} param0.venue - The address of the points contract
+ * @param {Hex} param0.selector - The selector for the issuance function on the points contract
+ * @param {bigint} param0.reward - The reward amount issued for each claim
+ * @param {bigint} param0.limit -  The maximum number of claims that can be made (one per address)
+ * @returns {*}
+ */
+export const preparePointsIncentivePayload = ({
+  venue,
+  selector,
+  reward,
+  limit,
+}: PointsIncentivePayload) => {
+  return encodeAbiParameters(
+    [
+      { type: 'address', name: 'venue' },
+      { type: 'bytes4', name: 'selector' },
+      { type: 'uint256', name: 'reward' },
+      { type: 'uint256', name: 'limit' },
+    ],
+    [venue, selector, reward, limit],
+  );
+};

package/src/Validators/SignerValidator.test.ts

@@ -0,0 +1,159 @@
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { isAddress, pad } from 'viem';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { accounts } from '@boostxyz/test/accounts';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+} from '@boostxyz/test/helpers';
+import { testAccount } from '@boostxyz/test/viem';
+import { SignerValidator } from './SignerValidator';
+
+let fixtures: Fixtures;
+
+function freshValidator(fixtures: Fixtures) {
+  return function freshValidator() {
+    // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
+    const account = accounts.at(1)!.account;
+    return fixtures.registry.initialize(
+      crypto.randomUUID(),
+      fixtures.core.SignerValidator({
+        signers: [defaultOptions.account.address, account],
+        validatorCaller: testAccount.address,
+      }),
+    );
+  };
+}
+
+describe('SignerValidator', () => {
+  beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
+  });
+
+  test('can successfully be deployed', async () => {
+    const action = new SignerValidator(defaultOptions, {
+      signers: [testAccount.address],
+      validatorCaller: testAccount.address,
+    });
+    await action.deploy();
+    expect(isAddress(action.assertValidAddress())).toBe(true);
+  });
+
+  test('initializes successfully', async () => {
+    const validator = await loadFixture(freshValidator(fixtures));
+    expect(await validator.signers(defaultOptions.account.address)).toBe(true);
+    // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
+    expect(await validator.signers(accounts.at(1)!.account)).toBe(true);
+    // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
+    expect(await validator.signers(accounts.at(2)!.account)).toBe(false);
+  });
+
+  test('can validate hashes', async () => {
+    const validator = await loadFixture(freshValidator(fixtures));
+
+    // Define the input data
+    const boostId = 5n;
+    const incentiveQuantity = 1;
+    const incentiveId = 0n;
+    const claimant = '0x24582544C98a86eE59687c4D5B55D78f4FffA666';
+    const incentiveData = pad('0xdef456232173821931823712381232131391321934');
+
+    // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
+    const trustedSigner = accounts.at(0)!;
+    // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
+    const untrustedSigner = accounts.at(2)!;
+
+    const claimDataPayload = await validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity,
+      claimant,
+      boostId: boostId,
+    });
+
+    const badClaimDataPayload = await validator.encodeClaimData({
+      signer: untrustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity,
+      claimant,
+      boostId: boostId,
+    });
+
+    // Validation using trusted signer
+    expect(
+      await validator.validate({
+        boostId: boostId,
+        incentiveId: incentiveId,
+        claimData: claimDataPayload,
+        claimant: claimant,
+      }),
+    ).toBe(true);
+
+    // Validation using untrusted signer should throw an error
+    try {
+      await validator.validate({
+        boostId: boostId,
+        incentiveId: incentiveId,
+        claimData: badClaimDataPayload,
+        claimant: claimant,
+      });
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+    }
+  });
+  test('will not revalidate the same hash', async () => {
+    const validator = await loadFixture(freshValidator(fixtures));
+
+    // Define the input data
+    const boostId = 5n;
+    const incentiveQuantity = 1;
+    const incentiveId = 0n;
+    const claimant = '0x24582544C98a86eE59687c4D5B55D78f4FffA666';
+    const incentiveData = pad('0xdef456232173821931823712381232131391321934');
+
+    // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
+    const trustedSigner = accounts.at(0)!;
+
+    const claimDataPayload = await validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity,
+      claimant,
+      boostId: boostId,
+    });
+
+    expect(
+      await validator.validate({
+        boostId,
+        incentiveId,
+        claimant,
+        claimData: claimDataPayload,
+      }),
+    ).toBe(true);
+
+    // Attempt to validate the same hash again (should throw an error)
+    try {
+      await validator.validate({
+        boostId,
+        incentiveId,
+        claimData: claimDataPayload,
+        claimant,
+      });
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+    }
+  });
+
+  test('can set authorized', async () => {
+    const validator = await loadFixture(freshValidator(fixtures));
+    // biome-ignore lint/style/noNonNullAssertion: this will never be undefined
+    const newSigner = accounts.at(2)!.account;
+    expect(await validator.signers(newSigner)).toBe(false);
+    await validator.setAuthorized([newSigner], [true]);
+    expect(await validator.signers(newSigner)).toBe(true);
+  });
+});