test(sdk): erc721mint action

Author: sammccord

packages/sdk/src/Actions/ERC721MintAction.test.ts

@@ -1,9 +1,51 @@
-import { isAddress, zeroAddress } from 'viem';
-import { describe, expect, test } from 'vitest';
-import { defaultOptions } from '../../test/helpers';
+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';
 
-describe('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('ContractAction', () => {
+  beforeEach(async () => {
+    erc721 = await loadFixture(fundErc721(defaultOptions));
+  });
+
   test('can successfully be deployed', async () => {
     const action = new ERC721MintAction(defaultOptions, {
       chainId: BigInt(31_337),
@@ -14,4 +56,56 @@ describe('ERC721MintAction', () => {
     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(parseEther('0.1'));
+  });
+
+  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],
+      }),
+    );
+  });
+
+  test('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);
+  });
 });

packages/sdk/src/Actions/ERC721MintAction.ts

@@ -6,6 +6,7 @@ import {
   readErc721MintActionGetComponentInterface,
   readErc721MintActionPrepare,
   readErc721MintActionSupportsInterface,
+  readErc721MintActionValidated,
   simulateErc721MintActionExecute,
   simulateErc721MintActionValidate,
   writeErc721MintActionExecute,
@@ -26,6 +27,19 @@ export class ERC721MintAction extends ContractAction {
   public static override base = import.meta.env.VITE_ERC721_MINT_ACTION_BASE;
   public static override registryType: RegistryType = RegistryType.ACTION;
 
+  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],
+    });
+  }
+
   public override async execute(
     data: Hex,
     params?: WriteParams<typeof erc721MintActionAbi, 'execute'>,

packages/sdk/test/helpers.ts

@@ -1,5 +1,6 @@
 import {
   readMockErc20BalanceOf,
+  readMockErc721BalanceOf,
   readMockErc1155BalanceOf,
   writeMockErc20Approve,
   writeMockErc1155SetApprovalForAll,
@@ -320,6 +321,26 @@ export function fundErc20(
   };
 }
 
+export function fundErc721(
+  options: DeployableTestOptions,
+  erc721?: MockERC721,
+  funded: Address[] = [],
+  amount: bigint = parseEther('100'),
+) {
+  return async function fundErc721() {
+    if (!erc721) erc721 = await freshERC721();
+    for (const address of [options.account.address, ...(funded ?? [])]) {
+      await erc721.mint(address);
+      const balance = await readMockErc721BalanceOf(options.config, {
+        address: erc721.assertValidAddress(),
+        args: [address],
+      });
+      if (amount !== balance) throw new Error(`Balance did not match`);
+    }
+    return erc721;
+  };
+}
+
 export function fundPoints(
   options: DeployableTestOptions,
   points?: MockPoints,