@boostxyz/sdk 0.0.0-alpha.8 → 1.1.0-alpha.22

package/src/Actions/ContractAction.ts

@@ -9,23 +9,61 @@ import {
   writeContractActionExecute,
 } from '@boostxyz/evm';
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/actions/ContractAction.sol/ContractAction.json';
-import type { Abi, Address, ContractEventName, Hex } from 'viem';
+import {
+  type Abi,
+  type Address,
+  type ContractEventName,
+  type Hex,
+  encodeAbiParameters,
+  parseAbiParameters,
+} from 'viem';
 import type {
   DeployableOptions,
   GenericDeployableParams,
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
 import {
-  type ContractActionPayload,
   type GenericLog,
   type ReadParams,
   RegistryType,
   type WriteParams,
-  prepareContractActionPayload,
 } from '../utils';
 
 export { contractActionAbi };
-export type { ContractActionPayload };
+
+/**
+ * The object representation of a `ContractAction.InitPayload`
+ *
+ * @export
+ * @interface ContractActionPayload
+ * @typedef {ContractActionPayload}
+ */
+export interface ContractActionPayload {
+  /**
+   * The chain ID on which the target exists
+   *
+   * @type {bigint}
+   */
+  chainId: bigint;
+  /**
+   * The target contract address
+   *
+   * @type {Address}
+   */
+  target: Address;
+  /**
+   * The selector for the function to be called
+   *
+   * @type {Hex}
+   */
+  selector: Hex;
+  /**
+   * The native token value to send with the function call
+   *
+   * @type {bigint}
+   */
+  value: bigint;
+}
 
 /**
  * A generic `viem.Log` event with support for `ContractAction` event types.
@@ -61,10 +99,9 @@ export class ContractAction<
    *
    * @public
    * @static
-   * @type {Address}
+   * @type {Record<number, Address>}
    */
-  public static override base: Address = import.meta.env
-    .VITE_CONTRACT_ACTION_BASE;
+  public static override bases: Record<number, Address> = {};
   /**
    * @inheritdoc
    *
@@ -79,13 +116,13 @@ export class ContractAction<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof contractActionAbi, 'chainId'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async chainId(
     params?: ReadParams<typeof contractActionAbi, 'chainId'>,
   ) {
-    return readContractActionChainId(this._config, {
+    return await readContractActionChainId(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
@@ -98,11 +135,11 @@ export class ContractAction<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof contractActionAbi, 'target'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<`0x${string}`>}
    */
   public async target(params?: ReadParams<typeof contractActionAbi, 'target'>) {
-    return readContractActionTarget(this._config, {
+    return await readContractActionTarget(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
@@ -116,13 +153,13 @@ export class ContractAction<
    * @example `function mint(address to, uint256 amount)`
    * @public
    * @async
-   * @param {?ReadParams<typeof contractActionAbi, 'selector'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<`0x${string}`>}
    */
   public async selector(
     params?: ReadParams<typeof contractActionAbi, 'selector'>,
   ) {
-    return readContractActionSelector(this._config, {
+    return await readContractActionSelector(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
@@ -135,11 +172,11 @@ export class ContractAction<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof contractActionAbi, 'value'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async value(params?: ReadParams<typeof contractActionAbi, 'value'>) {
-    return readContractActionValue(this._config, {
+    return await readContractActionValue(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
@@ -153,14 +190,14 @@ export class ContractAction<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?WriteParams<typeof contractActionAbi, 'execute'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<readonly [boolean, `0x${string}`]>}
    */
   public async execute(
     data: Hex,
     params?: WriteParams<typeof contractActionAbi, 'execute'>,
   ) {
-    return this.awaitResult(this.executeRaw(data, params));
+    return await this.awaitResult(this.executeRaw(data, params));
   }
 
   /**
@@ -169,8 +206,8 @@ export class ContractAction<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?WriteParams<typeof contractActionAbi, 'execute'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: readonly [boolean, `0x${string}`]; }>}
    */
   public async executeRaw(
     data: Hex,
@@ -196,14 +233,14 @@ export class ContractAction<
    * @public
    * @async
    * @param {Hex} calldata
-   * @param {?ReadParams<typeof contractActionAbi, 'prepare'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<`0x${string}`>}
    */
   public async prepare(
     calldata: Hex,
     params?: ReadParams<typeof contractActionAbi, 'prepare'>,
   ) {
-    return readContractActionPrepare(this._config, {
+    return await readContractActionPrepare(this._config, {
       address: this.assertValidAddress(),
       args: [calldata],
       ...this.optionallyAttachAccount(),
@@ -236,3 +273,28 @@ export class ContractAction<
     };
   }
 }
+
+/**
+ * Given a {@link ContractActionPayload}, properly encode a `ContractAction.InitPayload` for use with {@link ContractAction} initialization.
+ *
+ * @param {ContractActionPayload} param0
+ * @param {bigint} param0.chainId - The chain ID on which the target exists
+ * @param {Address} param0.target - The target contract address
+ * @param {Hex} param0.selector - The selector for the function to be called
+ * @param {bigint} param0.value - The native token value to send with the function call
+ * @returns {Hex}
+ */
+export function prepareContractActionPayload({
+  chainId,
+  target,
+  selector,
+  value,
+}: ContractActionPayload) {
+  return encodeAbiParameters(
+    parseAbiParameters([
+      'ContractActionPayload payload',
+      'struct ContractActionPayload { uint256 chainId; address target; bytes4 selector; uint256 value; }',
+    ]),
+    [{ chainId, target, selector, value }],
+  );
+}

package/src/Actions/ERC721MintAction.test.ts

@@ -9,29 +9,29 @@ import {
   zeroAddress,
 } from 'viem';
 import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
-import type { MockERC721 } from '../../test/MockERC721';
-import { accounts } from '../../test/accounts';
+import type { MockERC721 } from '@boostxyz/test/MockERC721';
+import { accounts } from '@boostxyz/test/accounts';
 import {
   type Fixtures,
   defaultOptions,
   deployFixtures,
   fundErc721,
-} from '../../test/helpers';
+} from '@boostxyz/test/helpers';
 import { ERC721MintAction } from './ERC721MintAction';
 
 let fixtures: Fixtures, erc721: MockERC721;
 
 beforeAll(async () => {
-  fixtures = await loadFixture(deployFixtures);
+  fixtures = await loadFixture(deployFixtures(defaultOptions));
 });
 
 const mintSelector = toFunctionSelector('function mint(address to)');
 
 function nonPayableAction(fixtures: Fixtures, erc721: MockERC721) {
   return function nonPayableAction() {
-    return fixtures.registry.clone(
+    return fixtures.registry.initialize(
       crypto.randomUUID(),
-      new fixtures.bases.ERC721MintAction(defaultOptions, {
+      fixtures.core.ERC721MintAction({
         chainId: BigInt(31_337),
         target: erc721.assertValidAddress(),
         selector: mintSelector,
@@ -81,7 +81,7 @@ describe.skip('ERC721MintAction', () => {
 
   test('prepare will properly encode execution payload', async () => {
     const action = await loadFixture(nonPayableAction(fixtures, erc721));
-    const { account } = accounts.at(1)!;
+    const { account } = accounts[1];
     const payload = await action.prepare(
       encodeAbiParameters([{ type: 'address', name: 'address' }], [account]),
     );
@@ -97,7 +97,7 @@ describe.skip('ERC721MintAction', () => {
   // TODO implement execute
   test.skip('nonpayable execute', async () => {
     const action = await loadFixture(nonPayableAction(fixtures, erc721));
-    const { account } = accounts.at(1)!;
+    const { account } = accounts[1];
     const [success] = await action.execute(
       encodeAbiParameters(
         [

package/src/Actions/ERC721MintAction.ts

@@ -8,24 +8,37 @@ import {
   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 Address,
+  type ContractEventName,
+  type Hex,
+  encodeAbiParameters,
+  toHex,
+} 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';
+import {
+  ContractAction,
+  type ContractActionPayload,
+  prepareContractActionPayload,
+} from './ContractAction';
 
-export { erc721MintActionAbi, prepareERC721MintActionPayload };
-export type { ERC721MintActionPayload };
+export { erc721MintActionAbi };
+/**
+ * `ERC721MintActionPayload` is a re-exported `ContractActionPayload`
+ *
+ * @export
+ * @typedef {ERC721MintActionPayload}
+ */
+export type ERC721MintActionPayload = ContractActionPayload;
 
 /**
  * A generic `viem.Log` event with support for `ERC721MintAction` event types.
@@ -64,10 +77,9 @@ export class ERC721MintAction extends ContractAction<
    *
    * @public
    * @static
-   * @type {Address}
+   * @type {Record<number, Address>}
    */
-  public static override base: Address = import.meta.env
-    .VITE_ERC721_MINT_ACTION_BASE;
+  public static override bases: Record<number, Address> = {};
   /**
    * @inheritdoc
    *
@@ -84,14 +96,14 @@ export class ERC721MintAction extends ContractAction<
    * @public
    * @async
    * @param {bigint} token
-   * @param {?ReadParams<typeof erc721MintActionAbi, 'validated'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>}
    */
   public async validated(
     token: bigint,
     params?: ReadParams<typeof erc721MintActionAbi, 'validated'>,
   ) {
-    return readErc721MintActionValidated(this._config, {
+    return await 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
@@ -106,14 +118,14 @@ export class ERC721MintAction extends ContractAction<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?WriteParams<typeof erc721MintActionAbi, 'execute'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<readonly [boolean, `0x${string}`]>}
    */
   public override async execute(
     data: Hex,
     params?: WriteParams<typeof erc721MintActionAbi, 'execute'>,
   ) {
-    return this.awaitResult(this.executeRaw(data, params));
+    return await this.awaitResult(this.executeRaw(data, params));
   }
 
   /**
@@ -122,8 +134,8 @@ export class ERC721MintAction extends ContractAction<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?WriteParams<typeof erc721MintActionAbi, 'execute'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: readonly [boolean, `0x${string}`]; }>}
    */
   public override async executeRaw(
     data: Hex,
@@ -149,14 +161,14 @@ export class ERC721MintAction extends ContractAction<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?ReadParams<typeof erc721MintActionAbi, 'prepare'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<`0x${string}`>}
    */
   public override async prepare(
     data: Hex,
     params?: ReadParams<typeof erc721MintActionAbi, 'prepare'>,
   ) {
-    return readErc721MintActionPrepare(this._config, {
+    return await readErc721MintActionPrepare(this._config, {
       address: this.assertValidAddress(),
       args: [data],
       ...this.optionallyAttachAccount(),
@@ -166,34 +178,34 @@ export class ERC721MintAction extends ContractAction<
   }
 
   /**
-   * Validate that the action has been completed successfully
+   * Validate that the action has been completed successfully. This API is protected to prevent accidental signature burning.
    *
-   * @public
+   * @protected
    * @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
+   * @param {?WriteParams} [params]
+   * @returns {Promise<boolean>} - True if the action has been validated for the user
    */
-  public async validate(
+  protected async validate(
     holder: Address,
     tokenId: bigint,
     params?: WriteParams<typeof erc721MintActionAbi, 'validate'>,
   ) {
-    return this.awaitResult(this.validateRaw(holder, tokenId, params));
+    return await this.awaitResult(this.validateRaw(holder, tokenId, params));
   }
 
   /**
    * Validate that the action has been completed successfully
    *
-   * @public
+   * @protected
    * @async
    * @param {Address} holder - The holder
    * @param {BigInt} tokenId - The token ID
-   * @param {?WriteParams<typeof erc721MintActionAbi, 'validate'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the action has been validated for the user
    */
-  public async validateRaw(
+  protected async validateRaw(
     holder: Address,
     tokenId: bigint,
     params?: WriteParams<typeof erc721MintActionAbi, 'validate'>,
@@ -236,3 +248,44 @@ export class ERC721MintAction extends ContractAction<
     };
   }
 }
+
+/**
+ * Encodes a payload to validate that an action has been completed successfully.
+ *
+ *
+ * @export
+ * @param {Address} holder - The holder address
+ * @param {bigint} payload - The token ID
+ * @returns {Hex} - The first 20 bytes of the payload will be the holder address and the remaining bytes must be an encoded token ID (uint256)
+ */
+export function prepareERC721MintActionValidate(
+  holder: Address,
+  payload: bigint,
+) {
+  return encodeAbiParameters(
+    [
+      { type: 'address', name: 'holder' },
+      { type: 'bytes', name: 'payload' },
+    ],
+    [holder, toHex(payload)],
+  );
+}
+
+/**
+ * Given a {@link ContractActionPayload}, properly encode a `ContractAction.InitPayload` for use with {@link ERC721MintAction} initialization.
+ *
+ * @param {ContractActionPayload} param0
+ * @param {bigint} param0.chainId - The chain ID on which the target exists
+ * @param {Address} param0.target - The target contract address
+ * @param {Hex} param0.selector - The selector for the function to be called
+ * @param {bigint} param0.value - The native token value to send with the function call
+ * @returns {Hex}
+ */
+export function prepareERC721MintActionPayload({
+  chainId,
+  target,
+  selector,
+  value,
+}: ContractActionPayload) {
+  return prepareContractActionPayload({ chainId, target, selector, value });
+}