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

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,
+        },
+      },
+    ],
+  );
+}

package/src/Incentives/ERC20VariableIncentive.test.ts

@@ -0,0 +1,139 @@
+import { readMockErc20BalanceOf } from '@boostxyz/evm';
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { encodeAbiParameters, isAddress, parseEther, zeroAddress } from 'viem';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import { accounts } from '@boostxyz/test/accounts';
+import {
+  type BudgetFixtures,
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+  freshBoost,
+  fundBudget,
+} from '@boostxyz/test/helpers';
+import { ERC20VariableIncentive } from './ERC20VariableIncentive';
+
+const BOOST_CORE_CLAIM_FEE = parseEther('0.000075');
+
+let fixtures: Fixtures, budgets: BudgetFixtures;
+
+describe('ERC20VariableIncentive', () => {
+  beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
+  });
+
+  beforeEach(async () => {
+    budgets = await loadFixture(fundBudget(defaultOptions, fixtures));
+  });
+
+  test('can successfully be deployed', async () => {
+    const action = new ERC20VariableIncentive(defaultOptions, {
+      asset: zeroAddress,
+      reward: 1n,
+      limit: 1n,
+      manager: zeroAddress,
+    });
+    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 erc20VariableIncentive = new fixtures.bases.ERC20VariableIncentive(
+      defaultOptions,
+      {
+        asset: budgets.erc20.assertValidAddress(),
+        reward: 1n,
+        limit: 1n,
+        manager: zeroAddress,
+      },
+    );
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20VariableIncentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveQuantity = 1;
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData: encodeAbiParameters(
+        [{ name: '', type: 'uint256' }],
+        [parseEther('1')],
+      ),
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity,
+      claimant,
+      boostId: boost.id,
+    });
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      { value: BOOST_CORE_CLAIM_FEE },
+    );
+    expect(
+      await readMockErc20BalanceOf(defaultOptions.config, {
+        address: budgets.erc20.assertValidAddress(),
+        args: [claimant],
+      }),
+    ).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 erc20VariableIncentive = new fixtures.bases.ERC20VariableIncentive(
+      defaultOptions,
+      {
+        asset: budgets.erc20.assertValidAddress(),
+        reward: 1n,
+        limit: 1n,
+        manager: zeroAddress,
+      },
+    );
+    const boost = await freshBoost(fixtures, {
+      budget: budgets.budget,
+      incentives: [erc20VariableIncentive],
+    });
+
+    const claimant = trustedSigner.account;
+    const incentiveQuantity = 1;
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData: encodeAbiParameters(
+        [{ name: '', type: 'uint256' }],
+        [parseEther('1')],
+      ),
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity,
+      claimant,
+      boostId: boost.id,
+    });
+
+    await fixtures.core.claimIncentive(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      { value: BOOST_CORE_CLAIM_FEE },
+    );
+    try {
+      await fixtures.core.claimIncentive(
+        boost.id,
+        0n,
+        referrer,
+        claimDataPayload,
+        { value: BOOST_CORE_CLAIM_FEE },
+      );
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+    }
+  });
+});