@boostxyz/sdk 0.0.0-alpha.17 → 0.0.0-alpha.19

package/src/Incentives/ERC20Incentive.ts

@@ -130,8 +130,8 @@ export class ERC20Incentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20IncentiveAbi, 'owner'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Address>}
    */
   public async owner(params?: ReadParams<typeof erc20IncentiveAbi, 'owner'>) {
     return await readErc20IncentiveOwner(this._config, {
@@ -147,7 +147,7 @@ export class ERC20Incentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20IncentiveAbi, 'currentReward'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>} - The current reward
    */
   public async currentReward(
@@ -166,7 +166,7 @@ export class ERC20Incentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20IncentiveAbi, 'claims'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async claims(params?: ReadParams<typeof erc20IncentiveAbi, 'claims'>) {
@@ -184,7 +184,7 @@ export class ERC20Incentive extends DeployableTarget<
    * @public
    * @async
    * @param {Address} address
-   * @param {?ReadParams<typeof erc20IncentiveAbi, 'claimed'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<boolean>}
    */
   public async claimed(
@@ -204,7 +204,7 @@ export class ERC20Incentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20IncentiveAbi, 'asset'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Address>}
    */
   public async asset(params?: ReadParams<typeof erc20IncentiveAbi, 'asset'>) {
@@ -220,7 +220,7 @@ export class ERC20Incentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20IncentiveAbi, 'strategy'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<StrategyType>}
    */
   public strategy(
@@ -238,7 +238,7 @@ export class ERC20Incentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20IncentiveAbi, 'reward'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async reward(params?: ReadParams<typeof erc20IncentiveAbi, 'reward'>) {
@@ -254,8 +254,8 @@ export class ERC20Incentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof erc20IncentiveAbi, 'limit'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>}
    */
   public async limit(params?: ReadParams<typeof erc20IncentiveAbi, 'limit'>) {
     return await readErc20IncentiveLimit(this._config, {
@@ -271,7 +271,7 @@ export class ERC20Incentive extends DeployableTarget<
    * @public
    * @async
    * @param {bigint} i - Index of address
-   * @param {?ReadParams<typeof erc20IncentiveAbi, 'entries'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Address>}
    */
   public async entries(
@@ -292,7 +292,7 @@ export class ERC20Incentive extends DeployableTarget<
    * @public
    * @async
    * @param {ClaimPayload} payload
-   * @param {?WriteParams<typeof erc20IncentiveAbi, 'claim'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} - Returns true if successfully claimed
    */
   protected async claim(
@@ -308,8 +308,8 @@ export class ERC20Incentive extends DeployableTarget<
    * @public
    * @async
    * @param {ClaimPayload} payload
-   * @param {?WriteParams<typeof erc20IncentiveAbi, 'claim'>} [params]
-   * @returns {Promise<boolean>} - Returns true if successfully claimed
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - Returns true if successfully claimed
    */
   protected async claimRaw(
     payload: ClaimPayload,
@@ -335,7 +335,7 @@ export class ERC20Incentive extends DeployableTarget<
    * @public
    * @async
    * @param {ClaimPayload} payload
-   * @param {?WriteParams<typeof erc20IncentiveAbi, 'clawback'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} -  True if the assets were successfully clawbacked
    */
   public async clawback(
@@ -351,8 +351,8 @@ export class ERC20Incentive extends DeployableTarget<
    * @public
    * @async
    * @param {ClaimPayload} payload
-   * @param {?WriteParams<typeof erc20IncentiveAbi, 'clawback'>} [params]
-   * @returns {Promise<boolean>} -  True if the assets were successfully clawbacked
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} -  True if the assets were successfully clawbacked
    */
   public async clawbackRaw(
     payload: ClaimPayload,
@@ -378,8 +378,8 @@ export class ERC20Incentive extends DeployableTarget<
    * @public
    * @async
    * @param {ClaimPayload} payload
-   * @param {?ReadParams<typeof erc20IncentiveAbi, 'isClaimable'>} [params]
-   * @returns {unknown} = True if the incentive is claimable based on the data payload
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} = True if the incentive is claimable based on the data payload
    */
   public async isClaimable(
     payload: ClaimPayload,
@@ -398,7 +398,7 @@ export class ERC20Incentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?WriteParams<typeof erc20IncentiveAbi, 'drawRaffle'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<void>}
    */
   public async drawRaffle(
@@ -412,8 +412,8 @@ export class ERC20Incentive extends DeployableTarget<
    *
    * @public
    * @async
-   * @param {?WriteParams<typeof erc20IncentiveAbi, 'drawRaffle'>} [params]
-   * @returns {Promise<void>}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
    */
   public async drawRaffleRaw(
     params?: WriteParams<typeof erc20IncentiveAbi, 'drawRaffle'>,
@@ -464,7 +464,7 @@ export class ERC20Incentive extends DeployableTarget<
  * @param {StrategyType} param0.strategy - The type of disbursement strategy for the incentive. `StrategyType.MINT` is not supported for `ERC20Incentives`
  * @param {bigint} param0.reward - The amount of the asset to distribute.
  * @param {bigint} param0.limit - How many times can this incentive be claimed.
- * @returns {*}
+ * @returns {Hex}
  */
 export function prepareERC20IncentivePayload({
   asset,

package/src/Incentives/ERC20VariableCriteriaIncentive.test.ts

@@ -0,0 +1,184 @@
+import { Mock } from 'node:test';
+import { selectors as eventSelectors } from '@boostxyz/signatures/events';
+import { selectors as funcSelectors } from '@boostxyz/signatures/functions';
+import type { MockERC20 } from '@boostxyz/test/MockERC20';
+import type { MockERC721 } from '@boostxyz/test/MockERC721';
+import { accounts } from '@boostxyz/test/accounts';
+import {
+  type BudgetFixtures,
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+  freshBoost,
+  fundBudget,
+  fundErc20,
+  fundErc721,
+} from '@boostxyz/test/helpers';
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { type Hex, isAddress, parseEther } from 'viem';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import { SignatureType } from '../Actions/EventAction';
+import type { Boost } from '../Boost';
+import type {
+  ERC20VariableCriteriaIncentive,
+  ERC20VariableCriteriaIncentivePayload,
+  IncentiveCriteria,
+} from './ERC20VariableCriteriaIncentive';
+
+/**
+ * A basic ERC721 mint scalar criteria for testing
+ *
+ * @param {MockERC721} erc721 - The ERC721 contract
+ * @returns {IncentiveCriteria} - Returns a basic incentive criteria
+ */
+export function basicErc721TransferScalarCriteria(
+  erc721: MockERC721,
+): IncentiveCriteria {
+  return {
+    criteriaType: SignatureType.FUNC,
+    signature: funcSelectors['transferFrom(address,address,uint256)'] as Hex, // Function selector for mint
+    fieldIndex: 2, // Field where the scalar value resides
+    targetContract: erc721.assertValidAddress(),
+  };
+}
+
+/**
+ * A basic ERC721 mint scalar criteria for testing
+ *
+ * @param {MockERC721} erc721 - The ERC721 contract
+ * @returns {IncentiveCriteria} - Returns a basic incentive criteria
+ */
+export function basicErc721MintScalarCriteria(
+  erc721: MockERC721,
+): IncentiveCriteria {
+  return {
+    criteriaType: SignatureType.EVENT,
+    signature: eventSelectors[
+      'Transfer(address indexed,address indexed,uint256 indexed)'
+    ] as Hex, // Function selector for mint
+    fieldIndex: 2, // Field where the scalar value resides
+    targetContract: erc721.assertValidAddress(),
+  };
+}
+
+/**
+ * A basic ERC721 mint scalar payload for testing
+ *
+ * @param {MockERC721} erc721 - The ERC721 contract
+ * @returns {ERC20VariableCriteriaIncentivePayload} - Returns a full variable criteria incentive payload
+ */
+export function basicErc721TransferScalarPayload(
+  erc721: MockERC721,
+): ERC20VariableCriteriaIncentivePayload {
+  return {
+    asset: erc721.assertValidAddress(),
+    reward: 1n,
+    limit: 1n,
+    criteria: basicErc721TransferScalarCriteria(erc721),
+  };
+}
+
+let fixtures: Fixtures,
+  erc20: MockERC20,
+  erc721: MockERC721,
+  erc20Incentive: ERC20VariableCriteriaIncentive,
+  budgets: BudgetFixtures,
+  boost: Boost;
+
+describe('ERC20VariableCriteriaIncentive', () => {
+  beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
+  });
+
+  beforeEach(async () => {
+    budgets = await loadFixture(fundBudget(defaultOptions, fixtures));
+    erc20 = await loadFixture(fundErc20(defaultOptions));
+    erc721 = await loadFixture(fundErc721(defaultOptions));
+    erc20Incentive = fixtures.core.ERC20VariableCriteriaIncentive({
+      asset: budgets.erc20.assertValidAddress(),
+      reward: 1n,
+      limit: 1n,
+      criteria: basicErc721TransferScalarCriteria(erc721),
+    });
+
+    boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20Incentive],
+    });
+    expect(isAddress(boost.incentives[0]!.assertValidAddress())).toBe(true);
+  });
+
+  describe('getIncentiveCriteria', () => {
+    test('should fetch incentive criteria successfully', async () => {
+      const incentive = boost.incentives[0] as ERC20VariableCriteriaIncentive;
+      const criteria = await incentive.getIncentiveCriteria();
+      expect(criteria).toMatchObject({
+        criteriaType: SignatureType.FUNC,
+        signature: expect.any(String),
+        fieldIndex: expect.any(Number),
+        targetContract: expect.any(String),
+      });
+    });
+  });
+
+  describe('getIncentiveScalar', () => {
+    test('should return a valid scalar for function-based criteria', async () => {
+      const recipient = accounts[1].account;
+
+      const { hash } = await erc721.transferFromRaw(
+        accounts[0].account,
+        recipient,
+        1n,
+      );
+      const scalar = await erc20Incentive.getIncentiveScalar({ hash });
+
+      expect(scalar).toBe(1n);
+    });
+
+    test('should return a valid scalar for event-based criteria', async () => {
+      erc20Incentive = fixtures.core.ERC20VariableCriteriaIncentive({
+        asset: budgets.erc20.assertValidAddress(),
+        reward: 1n,
+        limit: 1n,
+        criteria: basicErc721MintScalarCriteria(erc721),
+      });
+
+      boost = await freshBoost(fixtures, {
+        budget: budgets.budget,
+        incentives: [erc20Incentive],
+      });
+      const recipient = accounts[1].account;
+      const { hash } = await erc721.transferFromRaw(
+        accounts[0].account,
+        recipient,
+        1n,
+      );
+      const scalar = await erc20Incentive.getIncentiveScalar({ hash });
+
+      expect(scalar).toBe(1n);
+    });
+
+    test('should throw NoMatchingLogsError for event criteria with no matching logs', async () => {
+      const recipient = accounts[1].account;
+
+      const { hash } = await erc20.mintRaw(recipient, parseEther('100'));
+
+      try {
+        await erc20Incentive.getIncentiveScalar({ hash });
+      } catch (e) {
+        expect((e as Error).name).toBe('DecodedArgsError');
+      }
+    });
+
+    test('should throw DecodedArgsError for invalid function-based data', async () => {
+      const recipient = accounts[1].account;
+      const { hash } = await erc20.mintRaw(recipient, parseEther('100'));
+
+      try {
+        await erc20Incentive.getIncentiveScalar({ hash });
+      } catch (e) {
+        expect((e as Error).name).toBe('DecodedArgsError');
+      }
+    });
+  });
+});

package/src/Incentives/ERC20VariableCriteriaIncentive.ts

@@ -0,0 +1,309 @@
+import {
+  erc20VariableCriteriaIncentiveAbi,
+  readErc20VariableCriteriaIncentiveGetIncentiveCriteria,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/incentives/ERC20VariableCriteriaIncentive.sol/ERC20VariableCriteriaIncentive.json';
+import events from '@boostxyz/signatures/events';
+import functions from '@boostxyz/signatures/functions';
+import { getTransaction, getTransactionReceipt } from '@wagmi/core';
+import {
+  type AbiEvent,
+  type AbiFunction,
+  type Address,
+  type Hex,
+  type Log,
+  decodeFunctionData,
+  encodeAbiParameters,
+  parseEventLogs,
+} from 'viem';
+import { ERC20VariableCriteriaIncentive as ERC20VariableCriteriaIncentiveBases } from '../../dist/deployments.json';
+import { SignatureType } from '../Actions/EventAction';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import {
+  DecodedArgsError,
+  FieldActionValidationError,
+  IncentiveCriteriaNotFoundError,
+  InvalidCriteriaTypeError,
+  NoMatchingLogsError,
+} from '../errors';
+import type { ReadParams } from '../utils';
+import { ERC20VariableIncentive } from './ERC20VariableIncentive';
+
+export interface ERC20VariableCriteriaIncentivePayload {
+  /**
+   * The address of the incentivized asset.
+   *
+   * @type {Address}
+   */
+  asset: Address;
+  /**
+   * The amount of the asset to distribute as reward.
+   *
+   * @type {bigint}
+   */
+  reward: bigint;
+  /**
+   * The total spending limit of the asset that will be distributed.
+   *
+   * @type {bigint}
+   */
+  limit: bigint;
+  /**
+   * The criteria for the incentive that determines how the reward is distributed.
+   *
+   * @type {IncentiveCriteria}
+   */
+  criteria: IncentiveCriteria;
+}
+
+export interface IncentiveCriteria {
+  /**
+   * The type of criteria used, either function signature or event signature.
+   *
+   * @type {SignatureType}
+   */
+  criteriaType: SignatureType;
+  /**
+   * The function or event signature used for criteria matching.
+   *
+   * @type {Hex}
+   */
+  signature: Hex;
+  /**
+   * The index of the field from where the scalar value is extracted.
+   *
+   * @type {number}
+   */
+  fieldIndex: number;
+  /**
+   * The address of the contract where the event/function is called/emitted.
+   *
+   * @type {Address}
+   */
+  targetContract: Address;
+}
+
+export interface ReadIncentiveCriteriaParams
+  extends ReadParams<
+    typeof erc20VariableCriteriaIncentiveAbi,
+    'getIncentiveCriteria'
+  > {}
+
+export interface GetIncentiveScalarParams {
+  hash: Hex;
+}
+
+/**
+ * Extended ERC20 Variable Criteria Incentive class that fetches incentive criteria and scalar
+ */
+export class ERC20VariableCriteriaIncentive extends DeployableTarget<
+  ERC20VariableCriteriaIncentivePayload,
+  typeof erc20VariableCriteriaIncentiveAbi
+> {
+  public override readonly abi = erc20VariableCriteriaIncentiveAbi;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Record<number, Address>}
+   */
+  public static override bases: Record<number, Address> = {
+    ...(ERC20VariableCriteriaIncentiveBases as Record<number, Address>),
+  };
+
+  /**
+   *Functions from the ERC20VariableIncentive contract
+   */
+
+  /**
+   * Fetches the IncentiveCriteria struct from the contract
+   *
+   * @returns {Promise<IncentiveCriteria>} Incentive criteria structure
+   * @throws {IncentiveCriteriaNotFoundError}
+   */
+  public async getIncentiveCriteria(): Promise<IncentiveCriteria> {
+    try {
+      const criteria =
+        await readErc20VariableCriteriaIncentiveGetIncentiveCriteria(
+          this._config,
+          {
+            address: this.assertValidAddress(),
+          },
+        );
+
+      return criteria;
+    } catch (e) {
+      throw new IncentiveCriteriaNotFoundError(e as Error);
+    }
+  }
+
+  /**
+   * Fetches the incentive scalar from a transaction hash
+   *
+   * @param {GetIncentiveScalarParams} params
+   * @returns {Promise<bigint>}
+   * @throws {InvalidCriteriaTypeError | NoMatchingLogsError | DecodedArgsError}
+   */
+  public async getIncentiveScalar({
+    hash,
+  }: GetIncentiveScalarParams): Promise<bigint> {
+    const criteria = await this.getIncentiveCriteria();
+    const transaction = await getTransaction(this._config, {
+      hash,
+    });
+    if (criteria.criteriaType === SignatureType.EVENT) {
+      const transactionReceipt = await getTransactionReceipt(this._config, {
+        hash,
+      });
+
+      const logs = transactionReceipt.logs;
+
+      if (logs.length === 0) {
+        throw new NoMatchingLogsError(
+          `No logs found for event signature ${criteria.signature}`,
+        );
+      }
+
+      // Decode the event log
+      try {
+        // Decode function data
+        const eventAbi = (events.abi as Record<Hex, AbiEvent>)[
+          criteria.signature
+        ] as AbiEvent;
+        const decodedEvents = parseEventLogs({
+          abi: [eventAbi],
+          logs,
+        });
+        if (decodedEvents == undefined || decodedEvents.length === 0) {
+          throw new NoMatchingLogsError(
+            `No logs found for event signature ${criteria.signature}`,
+          );
+        }
+        const scalarValue = (decodedEvents[0]?.args as string[])[
+          criteria.fieldIndex
+        ];
+
+        if (scalarValue === undefined) {
+          throw new DecodedArgsError(
+            `Decoded argument at index ${criteria.fieldIndex} is undefined`,
+          );
+        }
+        return BigInt(scalarValue);
+      } catch (e) {
+        throw new DecodedArgsError(
+          `Failed to decode event log for signature ${criteria.signature}: ${(e as Error).message}`,
+        );
+      }
+    } else if (criteria.criteriaType === SignatureType.FUNC) {
+      // Fetch the transaction data
+      try {
+        // Decode function data
+        const func = (functions.abi as Record<Hex, AbiFunction>)[
+          criteria.signature
+        ] as AbiFunction;
+
+        const decodedFunction = decodeFunctionData({
+          abi: [func],
+          data: transaction.input,
+        });
+        const scalarValue = decodedFunction.args[criteria.fieldIndex] as string;
+        if (scalarValue === undefined || scalarValue === null) {
+          throw new DecodedArgsError(
+            `Decoded argument at index ${criteria.fieldIndex} is undefined`,
+          );
+        }
+        return BigInt(scalarValue);
+      } catch (e) {
+        throw new DecodedArgsError(
+          `Failed to decode function data for signature ${criteria.signature}: ${(e as Error).message}`,
+        );
+      }
+    } else {
+      throw new InvalidCriteriaTypeError(
+        `Invalid criteria type ${criteria.criteriaType}`,
+      );
+    }
+  }
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @param {?ERC20VariableCriteriaIncentivePayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: ERC20VariableCriteriaIncentivePayload,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [payload, options] = this.validateDeploymentConfig(
+      _payload,
+      _options,
+    );
+    return {
+      abi: erc20VariableCriteriaIncentiveAbi,
+      bytecode: bytecode as Hex,
+      args: [prepareERC20VariableCriteriaIncentivePayload(payload)],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}
+
+/**
+ *
+ *
+ * @param {InitPayloadExtended} param0
+ * @param {Address} param0.asset - The address of the ERC20 asset to incentivize.
+ * @param {bigint} param0.reward - The reward amount to distribute per action.
+ * @param {bigint} param0.limit - The total limit of the asset distribution.
+ * @param {IncentiveCriteria} param0.criteria - The incentive criteria for reward distribution.
+ * @returns {Hex}
+ */
+export function prepareERC20VariableCriteriaIncentivePayload({
+  asset,
+  reward,
+  limit,
+  criteria,
+}: ERC20VariableCriteriaIncentivePayload) {
+  return encodeAbiParameters(
+    [
+      {
+        type: 'tuple',
+        name: 'initPayloadExtended',
+        components: [
+          { type: 'address', name: 'asset' },
+          { type: 'uint256', name: 'reward' },
+          { type: 'uint256', name: 'limit' },
+          {
+            type: 'tuple',
+            name: 'criteria',
+            components: [
+              { type: 'uint8', name: 'criteriaType' },
+              { type: 'bytes32', name: 'signature' },
+              { type: 'uint8', name: 'fieldIndex' },
+              { type: 'address', name: 'targetContract' },
+            ],
+          },
+        ],
+      },
+    ],
+    [
+      {
+        asset: asset,
+        reward: reward,
+        limit: limit,
+        criteria: {
+          criteriaType: criteria.criteriaType,
+          signature: criteria.signature,
+          fieldIndex: criteria.fieldIndex,
+          targetContract: criteria.targetContract,
+        },
+      },
+    ],
+  );
+}