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

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@boostxyz/sdk",
-  "version": "0.0.0-alpha.3",
+  "version": "0.0.0-alpha.6",
   "license": "GPL-3.0-or-later",
   "type": "module",
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "repository": "https://github.com/rabbitholegg/boost-protocol",
   "author": "Boost Team<boost-team@boost.xyz>",
   "access": "public",
+  "private": false,
   "browserslist": [
     "node >=14",
     "edge >=88",
@@ -177,7 +179,7 @@
     "@boostxyz/signatures": "0.0.0-alpha.0"
   },
   "optionalDependencies": {
-    "@boostxyz/evm": "0.0.0-alpha.0"
+    "@boostxyz/evm": "0.0.0-alpha.1"
   },
   "peerDependencies": {
     "@wagmi/core": "2",

package/src/Actions/Action.test.ts

@@ -0,0 +1,77 @@
+import { selectors } from '@boostxyz/signatures/events';
+import { loadFixture } from '@nomicfoundation/hardhat-toolbox-viem/network-helpers';
+import type { Hex } 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, actionFromAddress } from './Action';
+
+let fixtures: Fixtures, erc721: MockERC721;
+
+export 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,
+        },
+      },
+    ],
+  };
+}
+
+export function cloneEventAction(fixtures: Fixtures, erc721: MockERC721) {
+  return function cloneEventAction() {
+    return fixtures.registry.clone(
+      crypto.randomUUID(),
+      new fixtures.bases.EventAction(
+        defaultOptions,
+        basicErc721TransferAction(erc721),
+      ),
+    );
+  };
+}
+
+beforeAll(async () => {
+  fixtures = await loadFixture(deployFixtures);
+});
+
+describe('Action', () => {
+  beforeEach(async () => {
+    erc721 = await loadFixture(fundErc721(defaultOptions));
+  });
+
+  test('can automatically instantiate EventAction given an address', async () => {
+    const _action = await loadFixture(cloneEventAction(fixtures, erc721));
+    expect(
+      await actionFromAddress(defaultOptions, _action.assertValidAddress()),
+    ).toBeInstanceOf(EventAction);
+  });
+});

package/src/Actions/Action.ts

@@ -0,0 +1,61 @@
+import { aActionAbi } from '@boostxyz/evm';
+import { AEventAction } from '@boostxyz/evm/deploys/componentInterfaces.json';
+import { readContract } from '@wagmi/core';
+import type { Address, Hex } from 'viem';
+import type { DeployableOptions } from '../Deployable/Deployable';
+import { InvalidComponentInterfaceError } from '../errors';
+import { EventAction } from './EventAction';
+
+export {
+  // ContractAction,
+  // ERC721MintAction,
+  EventAction,
+};
+
+/**
+ * A union type representing all valid protocol Action implementations
+ *
+ * @export
+ * @typedef {Action}
+ */
+export type Action = EventAction; // | ContractAction | ERC721MintAction
+
+/**
+ * A map of Action component interfaces to their constructors.
+ *
+ * @type {{ "0x7687b0ed": EventAction; }}
+ */
+export const ActionByComponentInterface = {
+  // ['0x6c3129aa']: ContractAction,
+  // ['0x97e083eb']: ERC721MintAction,
+  [AEventAction as Hex]: EventAction,
+};
+
+/**
+ * A function that will read a contract's component interface using `getComponentInterface` and return the correct instantiated instance.
+ *
+ * @export
+ * @async
+ * @param {DeployableOptions} options
+ * @param {Address} address
+ * @returns {Promise<EventAction>}
+ * @throws {@link InvalidComponentInterfaceError}
+ */
+export async function actionFromAddress(
+  options: DeployableOptions,
+  address: Address,
+) {
+  const interfaceId = (await readContract(options.config, {
+    abi: aActionAbi,
+    functionName: 'getComponentInterface',
+    address,
+  })) as keyof typeof ActionByComponentInterface;
+  const Ctor = ActionByComponentInterface[interfaceId];
+  if (!Ctor) {
+    throw new InvalidComponentInterfaceError(
+      Object.keys(ActionByComponentInterface) as Hex[],
+      interfaceId as Hex,
+    );
+  }
+  return new Ctor(options, address);
+}

package/src/Actions/ContractAction.test.ts

@@ -0,0 +1,199 @@
+import { mockErc20Abi, readMockErc20BalanceOf } from '@boostxyz/evm';
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { getClient } from '@wagmi/core';
+import {
+  ContractFunctionExecutionError,
+  encodeAbiParameters,
+  encodeFunctionData,
+  isAddress,
+  parseEther,
+  toFunctionSelector,
+  zeroAddress,
+} from 'viem';
+import { call } from 'viem/actions';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import type { MockERC20 } from '../../test/MockERC20';
+import { accounts } from '../../test/accounts';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+  fundErc20,
+} from '../../test/helpers';
+import { ContractAction } from './ContractAction';
+
+let fixtures: Fixtures, erc20: MockERC20;
+
+beforeAll(async () => {
+  fixtures = await loadFixture(deployFixtures);
+});
+
+const mintPayableSelector = toFunctionSelector(
+  'function mintPayable(address to, uint256 amount)',
+);
+
+const mintSelector = toFunctionSelector(
+  'function mint(address to, uint256 amount)',
+);
+
+function payableContractAction(fixtures: Fixtures, erc20: MockERC20) {
+  return function payableContractAction() {
+    return fixtures.registry.clone(
+      crypto.randomUUID(),
+      new fixtures.bases.ContractAction(defaultOptions, {
+        chainId: BigInt(31_337),
+        target: erc20.assertValidAddress(),
+        selector: mintPayableSelector,
+        value: parseEther('0.1'),
+      }),
+    );
+  };
+}
+
+function nonPayableAction(fixtures: Fixtures, erc20: MockERC20) {
+  return function nonPayableAction() {
+    return fixtures.registry.clone(
+      crypto.randomUUID(),
+      new fixtures.bases.ContractAction(defaultOptions, {
+        chainId: BigInt(31_337),
+        target: erc20.assertValidAddress(),
+        selector: mintSelector,
+        value: 0n,
+      }),
+    );
+  };
+}
+
+function otherAction(fixtures: Fixtures, erc20: MockERC20) {
+  return function nonPayableAction() {
+    return fixtures.registry.clone(
+      crypto.randomUUID(),
+      new fixtures.bases.ContractAction(defaultOptions, {
+        chainId: BigInt(31_337) + 1n,
+        target: erc20.assertValidAddress(),
+        selector: mintSelector,
+        value: parseEther('0.1'),
+      }),
+    );
+  };
+}
+
+describe.skip('ContractAction', () => {
+  beforeEach(async () => {
+    erc20 = await loadFixture(fundErc20(defaultOptions));
+  });
+
+  test('can successfully be deployed', async () => {
+    const action = new ContractAction(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(payableContractAction(fixtures, erc20));
+    expect(await action.chainId()).toBe(BigInt(31_337));
+  });
+
+  test('can read target', async () => {
+    const action = await loadFixture(payableContractAction(fixtures, erc20));
+    expect((await action.target()).toLowerCase()).toBe(
+      erc20.assertValidAddress().toLowerCase(),
+    );
+  });
+
+  test('can read selector', async () => {
+    const action = await loadFixture(payableContractAction(fixtures, erc20));
+    expect(await action.selector()).toBe(mintPayableSelector);
+  });
+
+  test('can read value', async () => {
+    const action = await loadFixture(payableContractAction(fixtures, erc20));
+    expect(await action.value()).toBe(parseEther('0.1'));
+  });
+
+  test('prepare will properly encode execution payload', async () => {
+    const action = await loadFixture(payableContractAction(fixtures, erc20));
+    const { account } = accounts.at(1)!;
+    const payload = await action.prepare(
+      encodeAbiParameters(
+        [
+          { type: 'address', name: 'address' },
+          { type: 'uint256', name: 'value' },
+        ],
+        [account, parseEther('100')],
+      ),
+    );
+    expect(payload).toBe(
+      encodeFunctionData({
+        abi: mockErc20Abi,
+        functionName: 'mintPayable',
+        args: [account, parseEther('100')],
+      }),
+    );
+  });
+
+  test('payable execute', async () => {
+    const action = await loadFixture(payableContractAction(fixtures, erc20));
+    const { account } = accounts.at(1)!;
+    await action.execute(
+      encodeAbiParameters(
+        [
+          { type: 'address', name: 'to' },
+          { type: 'uint256', name: 'amount' },
+        ],
+        [account, parseEther('0.1')],
+      ),
+      { value: parseEther('0.1') },
+    );
+    expect(
+      await readMockErc20BalanceOf(defaultOptions.config, {
+        address: erc20.assertValidAddress(),
+        args: [account],
+      }),
+    ).toBe(parseEther('0.1'));
+  });
+
+  test('nonpayable execute', async () => {
+    const action = await loadFixture(nonPayableAction(fixtures, erc20));
+    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);
+    expect(
+      await readMockErc20BalanceOf(defaultOptions.config, {
+        address: erc20.assertValidAddress(),
+        args: [account],
+      }),
+    ).toBe(parseEther('100'));
+  });
+
+  test('different chain id should throw', async () => {
+    const action = await loadFixture(otherAction(fixtures, erc20));
+    const { account } = accounts.at(1)!;
+    try {
+      await action.execute(
+        encodeAbiParameters(
+          [
+            { type: 'address', name: 'to' },
+            { type: 'uint256', name: 'amount' },
+          ],
+          [account, parseEther('100')],
+        ),
+      );
+    } catch (e) {
+      expect(e).toBeInstanceOf(ContractFunctionExecutionError);
+    }
+  });
+});

package/src/Actions/ContractAction.ts

@@ -0,0 +1,238 @@
+import {
+  contractActionAbi,
+  readContractActionChainId,
+  readContractActionPrepare,
+  readContractActionSelector,
+  readContractActionTarget,
+  readContractActionValue,
+  simulateContractActionExecute,
+  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 {
+  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 };
+
+/**
+ * A generic `viem.Log` event with support for `ContractAction` event types.
+ *
+ * @export
+ * @typedef {ContractActionLog}
+ * @template {ContractEventName<typeof contractActionAbi>} [event=ContractEventName<
+ *     typeof contractActionAbi
+ *   >]
+ */
+export type ContractActionLog<
+  event extends ContractEventName<typeof contractActionAbi> = ContractEventName<
+    typeof contractActionAbi
+  >,
+> = GenericLog<typeof contractActionAbi, event>;
+
+/**
+ * A generic contract action
+ *
+ * @export
+ * @class ContractAction
+ * @typedef {ContractAction}
+ * @extends {DeployableTarget<ContractActionPayload>}
+ */
+export class ContractAction<
+  ContractActionAbi extends Abi = typeof contractActionAbi,
+> extends DeployableTarget<ContractActionPayload, ContractActionAbi> {
+  //@ts-expect-error should never be constructed with variant typ
+  public override readonly abi = contractActionAbi;
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Address}
+   */
+  public static override base: Address = import.meta.env
+    .VITE_CONTRACT_ACTION_BASE;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.ACTION;
+
+  /**
+   * The target chain ID
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof contractActionAbi, 'chainId'>} [params]
+   * @returns {Promise<bigint>}
+   */
+  public async chainId(
+    params?: ReadParams<typeof contractActionAbi, 'chainId'>,
+  ) {
+    return 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
+      ...(params as any),
+    });
+  }
+
+  /**
+   * The target contract
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof contractActionAbi, 'target'>} [params]
+   * @returns {Promise<`0x${string}`>}
+   */
+  public async target(params?: ReadParams<typeof contractActionAbi, 'target'>) {
+    return 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
+      ...(params as any),
+    });
+  }
+
+  /**
+   * The selector for the function to be called
+   *
+   * @example `function mint(address to, uint256 amount)`
+   * @public
+   * @async
+   * @param {?ReadParams<typeof contractActionAbi, 'selector'>} [params]
+   * @returns {Promise<`0x${string}`>}
+   */
+  public async selector(
+    params?: ReadParams<typeof contractActionAbi, 'selector'>,
+  ) {
+    return 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
+      ...(params as any),
+    });
+  }
+
+  /**
+   * The native token value to send with the function call
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof contractActionAbi, 'value'>} [params]
+   * @returns {Promise<bigint>}
+   */
+  public async value(params?: ReadParams<typeof contractActionAbi, 'value'>) {
+    return 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
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Executes a prepared contract action
+   *
+   * @public
+   * @async
+   * @param {Hex} data
+   * @param {?WriteParams<typeof contractActionAbi, 'execute'>} [params]
+   * @returns {Promise<readonly [boolean, `0x${string}`]>}
+   */
+  public async execute(
+    data: Hex,
+    params?: WriteParams<typeof contractActionAbi, 'execute'>,
+  ) {
+    return this.awaitResult(this.executeRaw(data, params));
+  }
+
+  /**
+   * Executes a prepared contract action
+   *
+   * @public
+   * @async
+   * @param {Hex} data
+   * @param {?WriteParams<typeof contractActionAbi, 'execute'>} [params]
+   * @returns {unknown}
+   */
+  public async executeRaw(
+    data: Hex,
+    params?: WriteParams<typeof contractActionAbi, 'execute'>,
+  ) {
+    const { request, result } = await simulateContractActionExecute(
+      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: [data],
+      },
+    );
+    const hash = await writeContractActionExecute(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * The encoded execution payload
+   *
+   * @public
+   * @async
+   * @param {Hex} calldata
+   * @param {?ReadParams<typeof contractActionAbi, 'prepare'>} [params]
+   * @returns {unknown}
+   */
+  public async prepare(
+    calldata: Hex,
+    params?: ReadParams<typeof contractActionAbi, 'prepare'>,
+  ) {
+    return readContractActionPrepare(this._config, {
+      address: this.assertValidAddress(),
+      args: [calldata],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @param {?ContractActionPayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: ContractActionPayload,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [payload, options] = this.validateDeploymentConfig(
+      _payload,
+      _options,
+    );
+    return {
+      abi: contractActionAbi,
+      bytecode: bytecode as Hex,
+      args: [prepareContractActionPayload(payload)],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}