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

package/src/Actions/ERC721MintAction.test.ts

@@ -0,0 +1,112 @@
+import { mockErc721Abi } from '@boostxyz/evm';
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import {
+  encodeAbiParameters,
+  encodeFunctionData,
+  isAddress,
+  parseEther,
+  toFunctionSelector,
+  zeroAddress,
+} from 'viem';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import type { MockERC721 } from '../../test/MockERC721';
+import { accounts } from '../../test/accounts';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+  fundErc721,
+} from '../../test/helpers';
+import { ERC721MintAction } from './ERC721MintAction';
+
+let fixtures: Fixtures, erc721: MockERC721;
+
+beforeAll(async () => {
+  fixtures = await loadFixture(deployFixtures);
+});
+
+const mintSelector = toFunctionSelector('function mint(address to)');
+
+function nonPayableAction(fixtures: Fixtures, erc721: MockERC721) {
+  return function nonPayableAction() {
+    return fixtures.registry.clone(
+      crypto.randomUUID(),
+      new fixtures.bases.ERC721MintAction(defaultOptions, {
+        chainId: BigInt(31_337),
+        target: erc721.assertValidAddress(),
+        selector: mintSelector,
+        value: 0n,
+      }),
+    );
+  };
+}
+
+describe.skip('ERC721MintAction', () => {
+  beforeEach(async () => {
+    erc721 = await loadFixture(fundErc721(defaultOptions));
+  });
+
+  test('can successfully be deployed', async () => {
+    const action = new ERC721MintAction(defaultOptions, {
+      chainId: BigInt(31_337),
+      target: zeroAddress,
+      selector: '0xdeadbeef',
+      value: 2n,
+    });
+    await action.deploy();
+    expect(isAddress(action.assertValidAddress())).toBe(true);
+  });
+
+  test('can read chain id', async () => {
+    const action = await loadFixture(nonPayableAction(fixtures, erc721));
+    expect(await action.chainId()).toBe(BigInt(31_337));
+  });
+
+  test('can read target', async () => {
+    const action = await loadFixture(nonPayableAction(fixtures, erc721));
+    expect((await action.target()).toLowerCase()).toBe(
+      erc721.assertValidAddress().toLowerCase(),
+    );
+  });
+
+  test('can read selector', async () => {
+    const action = await loadFixture(nonPayableAction(fixtures, erc721));
+    expect(await action.selector()).toBe(mintSelector);
+  });
+
+  test('can read value', async () => {
+    const action = await loadFixture(nonPayableAction(fixtures, erc721));
+    expect(await action.value()).toBe(0n);
+  });
+
+  test('prepare will properly encode execution payload', async () => {
+    const action = await loadFixture(nonPayableAction(fixtures, erc721));
+    const { account } = accounts.at(1)!;
+    const payload = await action.prepare(
+      encodeAbiParameters([{ type: 'address', name: 'address' }], [account]),
+    );
+    expect(payload).toBe(
+      encodeFunctionData({
+        abi: mockErc721Abi,
+        functionName: 'mint',
+        args: [account],
+      }),
+    );
+  });
+
+  // TODO implement execute
+  test.skip('nonpayable execute', async () => {
+    const action = await loadFixture(nonPayableAction(fixtures, erc721));
+    const { account } = accounts.at(1)!;
+    const [success] = await action.execute(
+      encodeAbiParameters(
+        [
+          { type: 'address', name: 'to' },
+          { type: 'uint256', name: 'amount' },
+        ],
+        [account, parseEther('100')],
+      ),
+    );
+    expect(success).toBe(true);
+  });
+});

package/src/Actions/ERC721MintAction.ts

@@ -0,0 +1,238 @@
+import {
+  erc721MintActionAbi,
+  readErc721MintActionPrepare,
+  readErc721MintActionValidated,
+  simulateErc721MintActionExecute,
+  simulateErc721MintActionValidate,
+  writeErc721MintActionExecute,
+  writeErc721MintActionValidate,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/actions/ERC721MintAction.sol/ERC721MintAction.json';
+import type { Address, ContractEventName, Hex } from 'viem';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import {
+  type ERC721MintActionPayload,
+  type GenericLog,
+  type ReadParams,
+  RegistryType,
+  type WriteParams,
+  prepareERC721MintActionPayload,
+  prepareERC721MintActionValidate,
+} from '../utils';
+import { ContractAction } from './ContractAction';
+
+export { erc721MintActionAbi, prepareERC721MintActionPayload };
+export type { ERC721MintActionPayload };
+
+/**
+ * A generic `viem.Log` event with support for `ERC721MintAction` event types.
+ *
+ * @export
+ * @typedef {ERC721MintActionLog}
+ * @template {ContractEventName<
+ *     typeof erc721MintActionAbi
+ *   >} [event=ContractEventName<typeof erc721MintActionAbi>]
+ */
+export type ERC721MintActionLog<
+  event extends ContractEventName<
+    typeof erc721MintActionAbi
+  > = ContractEventName<typeof erc721MintActionAbi>,
+> = GenericLog<typeof erc721MintActionAbi, event>;
+
+/**
+ * A primitive action to mint and/or validate that an ERC721 token has been minted
+ * The action is expected to be prepared with the data payload for the minting of the token
+ * This a minimal generic implementation that should be extended if additional functionality or customizations are required
+ * It is expected that the target contract has an externally accessible mint function whose selector
+ *
+ * @export
+ * @class ERC721MintAction
+ * @typedef {ERC721MintAction}
+ * @extends {ContractAction}
+ */
+export class ERC721MintAction extends ContractAction<
+  typeof erc721MintActionAbi
+> {
+  //@ts-expect-error should never be constructed with variant typ
+  public override readonly abi = erc721MintActionAbi;
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Address}
+   */
+  public static override base: Address = import.meta.env
+    .VITE_ERC721_MINT_ACTION_BASE;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.ACTION;
+
+  /**
+   * The set of validated tokens
+   * This is intended to prevent multiple validations against the same token ID
+   *
+   * @public
+   * @async
+   * @param {bigint} token
+   * @param {?ReadParams<typeof erc721MintActionAbi, 'validated'>} [params]
+   * @returns {unknown}
+   */
+  public async validated(
+    token: bigint,
+    params?: ReadParams<typeof erc721MintActionAbi, 'validated'>,
+  ) {
+    return readErc721MintActionValidated(this._config, {
+      address: this.assertValidAddress(),
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+      args: [token],
+    });
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @async
+   * @param {Hex} data
+   * @param {?WriteParams<typeof erc721MintActionAbi, 'execute'>} [params]
+   * @returns {unknown}
+   */
+  public override async execute(
+    data: Hex,
+    params?: WriteParams<typeof erc721MintActionAbi, 'execute'>,
+  ) {
+    return this.awaitResult(this.executeRaw(data, params));
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @async
+   * @param {Hex} data
+   * @param {?WriteParams<typeof erc721MintActionAbi, 'execute'>} [params]
+   * @returns {unknown}
+   */
+  public override async executeRaw(
+    data: Hex,
+    params?: WriteParams<typeof erc721MintActionAbi, 'execute'>,
+  ) {
+    const { request, result } = await simulateErc721MintActionExecute(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [data],
+        ...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 writeErc721MintActionExecute(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @async
+   * @param {Hex} data
+   * @param {?ReadParams<typeof erc721MintActionAbi, 'prepare'>} [params]
+   * @returns {unknown}
+   */
+  public override async prepare(
+    data: Hex,
+    params?: ReadParams<typeof erc721MintActionAbi, 'prepare'>,
+  ) {
+    return readErc721MintActionPrepare(this._config, {
+      address: this.assertValidAddress(),
+      args: [data],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Validate that the action has been completed successfully
+   *
+   * @public
+   * @async
+   * @param {Address} holder - The holder
+   * @param {BigInt} tokenId - The token ID
+   * @param {?WriteParams<typeof erc721MintActionAbi, 'validate'>} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the action has been validated for the user
+   */
+  public async validate(
+    holder: Address,
+    tokenId: bigint,
+    params?: WriteParams<typeof erc721MintActionAbi, 'validate'>,
+  ) {
+    return this.awaitResult(this.validateRaw(holder, tokenId, params));
+  }
+
+  /**
+   * Validate that the action has been completed successfully
+   *
+   * @public
+   * @async
+   * @param {Address} holder - The holder
+   * @param {BigInt} tokenId - The token ID
+   * @param {?WriteParams<typeof erc721MintActionAbi, 'validate'>} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the action has been validated for the user
+   */
+  public async validateRaw(
+    holder: Address,
+    tokenId: bigint,
+    params?: WriteParams<typeof erc721MintActionAbi, 'validate'>,
+  ) {
+    const { request, result } = await simulateErc721MintActionValidate(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [prepareERC721MintActionValidate(holder, tokenId)],
+        ...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 writeErc721MintActionValidate(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @param {?ERC721MintActionPayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: ERC721MintActionPayload,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [payload, options] = this.validateDeploymentConfig(
+      _payload,
+      _options,
+    );
+    return {
+      abi: erc721MintActionAbi,
+      bytecode: bytecode as Hex,
+      args: [prepareERC721MintActionPayload(payload)],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}

package/src/Actions/EventAction.test.ts

@@ -0,0 +1,182 @@
+import {
+  readAActionGetComponentInterface,
+  readEventActionGetComponentInterface,
+} from '@boostxyz/evm';
+import { selectors } from '@boostxyz/signatures/events';
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { type Hex, type Log, isAddress } from 'viem';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import type { MockERC721 } from '../../test/MockERC721';
+import { accounts } from '../../test/accounts';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+  fundErc721,
+} from '../../test/helpers';
+import {
+  type EventActionPayloadSimple,
+  FilterType,
+  PrimitiveType,
+  SignatureType,
+} from '../utils';
+import { EventAction } from './EventAction';
+
+let fixtures: Fixtures, erc721: MockERC721;
+
+beforeAll(async () => {
+  fixtures = await loadFixture(deployFixtures);
+});
+
+function basicErc721TransferAction(
+  erc721: MockERC721,
+): EventActionPayloadSimple {
+  return {
+    actionClaimant: {
+      signatureType: SignatureType.EVENT,
+      signature: selectors['Transfer(address,address,uint256)'] as Hex,
+      fieldIndex: 2,
+      targetContract: erc721.assertValidAddress(),
+    },
+    actionSteps: [
+      {
+        signature: selectors['Transfer(address,address,uint256)'] as Hex,
+        signatureType: SignatureType.EVENT,
+        actionType: 0,
+        targetContract: erc721.assertValidAddress(),
+        actionParameter: {
+          filterType: FilterType.EQUAL,
+          fieldType: PrimitiveType.ADDRESS,
+          fieldIndex: 2,
+          filterData: accounts.at(1)!.account,
+        },
+      },
+    ],
+  };
+}
+
+function cloneEventAction(fixtures: Fixtures, erc721: MockERC721) {
+  return function cloneEventAction() {
+    return fixtures.registry.clone(
+      crypto.randomUUID(),
+      new fixtures.bases.EventAction(
+        defaultOptions,
+        basicErc721TransferAction(erc721),
+      ),
+    );
+  };
+}
+
+describe('EventAction', () => {
+  beforeEach(async () => {
+    erc721 = await loadFixture(fundErc721(defaultOptions));
+  });
+
+  test('can successfully be deployed', async () => {
+    const action = new EventAction(
+      defaultOptions,
+      basicErc721TransferAction(erc721),
+    );
+    await action.deploy();
+    expect(isAddress(action.assertValidAddress())).toBe(true);
+  });
+
+  test('can get an action step', async () => {
+    const action = await loadFixture(cloneEventAction(fixtures, erc721));
+    const step = await action.getActionStep(0);
+    if (!step) throw new Error('there should be an action step at this index');
+    step.targetContract = step.targetContract.toUpperCase() as Hex;
+    step.actionParameter.filterData =
+      step.actionParameter.filterData.toUpperCase() as Hex;
+    expect(step).toMatchObject({
+      signature: selectors['Transfer(address,address,uint256)'] as Hex,
+      signatureType: SignatureType.EVENT,
+      actionType: 0,
+      targetContract: erc721.assertValidAddress().toUpperCase(),
+      actionParameter: {
+        filterType: FilterType.EQUAL,
+        fieldType: PrimitiveType.ADDRESS,
+        fieldIndex: 2,
+        filterData: accounts.at(1)!.account.toUpperCase(),
+      },
+    });
+  });
+
+  test('can get all action steps', async () => {
+    const action = await loadFixture(cloneEventAction(fixtures, erc721));
+    const steps = await action.getActionSteps();
+    expect(steps.length).toBe(1);
+    const step = steps.at(0)!;
+    step.targetContract = step.targetContract.toUpperCase() as Hex;
+    step.actionParameter.filterData =
+      step.actionParameter.filterData.toUpperCase() as Hex;
+    expect(step).toMatchObject({
+      signature: selectors['Transfer(address,address,uint256)'] as Hex,
+      signatureType: SignatureType.EVENT,
+      actionType: 0,
+      targetContract: erc721.assertValidAddress().toUpperCase(),
+      actionParameter: {
+        filterType: FilterType.EQUAL,
+        fieldType: PrimitiveType.ADDRESS,
+        fieldIndex: 2,
+        filterData: accounts.at(1)!.account.toUpperCase(),
+      },
+    });
+  });
+
+  test('can get the total number of action steps', async () => {
+    const action = await loadFixture(cloneEventAction(fixtures, erc721));
+    const count = await action.getActionStepsCount();
+    expect(count).toBe(1);
+  });
+
+  test('can get the action claimant', async () => {
+    const action = await loadFixture(cloneEventAction(fixtures, erc721));
+    const claimant = await action.getActionClaimant();
+    claimant.targetContract = claimant.targetContract.toUpperCase() as Hex;
+    expect(claimant).toMatchObject({
+      signatureType: SignatureType.EVENT,
+      signature: selectors['Transfer(address,address,uint256)'] as Hex,
+      fieldIndex: 2,
+      targetContract: erc721.assertValidAddress().toUpperCase(),
+    });
+  });
+
+  test('with no logs, does not validate', async () => {
+    const action = await loadFixture(cloneEventAction(fixtures, erc721));
+    expect(await action.validateActionSteps()).toBe(false);
+  });
+
+  test('with a correct log, validates', async () => {
+    const action = await loadFixture(cloneEventAction(fixtures, erc721));
+    const recipient = accounts.at(1)!.account;
+    await erc721.approve(recipient, 1n);
+    await erc721.transferFrom(defaultOptions.account.address, recipient, 1n);
+    expect(await action.validateActionSteps()).toBe(true);
+  });
+
+  test('can supply your own logs to validate against', async () => {
+    const log = {
+      eventName: 'Transfer',
+      args: undefined,
+      address: erc721.assertValidAddress(),
+      blockHash:
+        '0xbf602f988260519805d032be46d6ff97fbefbee6924b21097074d6d0bc34eced',
+      blockNumber: 1203n,
+      data: '0x',
+      logIndex: 0,
+      removed: false,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+        '0x00000000000000000000000070997970c51812dc3a010c7d01b50e0d17dc79c8',
+        '0x0000000000000000000000000000000000000000000000000000000000000001',
+      ],
+      transactionHash:
+        '0xff0e6ab0c4961ec14b7b40afec83ed7d7a77582683512a262e641d21f82efea5',
+      transactionIndex: 0,
+    } as Log;
+    const action = await loadFixture(cloneEventAction(fixtures, erc721));
+    expect(await action.validateActionSteps({ logs: [log] })).toBe(true);
+  });
+});