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

package/src/AllowLists/AllowList.test.ts

@@ -0,0 +1,64 @@
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { beforeAll, describe, expect, test } from 'vitest';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+} from '@boostxyz/test/helpers';
+import {
+  SimpleAllowList,
+  SimpleDenyList,
+  allowListFromAddress,
+} from './AllowList';
+
+let fixtures: Fixtures;
+
+beforeAll(async () => {
+  fixtures = await loadFixture(deployFixtures(defaultOptions));
+});
+
+function freshAllowList(fixtures: Fixtures) {
+  return function freshAllowList() {
+    return fixtures.registry.initialize(
+      crypto.randomUUID(),
+      fixtures.core.SimpleAllowList({
+        owner: defaultOptions.account.address,
+        allowed: [defaultOptions.account.address],
+      }),
+    );
+  };
+}
+
+function freshDenyList(fixtures: Fixtures) {
+  return function freshDenyList() {
+    return fixtures.registry.initialize(
+      crypto.randomUUID(),
+      fixtures.core.SimpleDenyList({
+        owner: defaultOptions.account.address,
+        denied: [defaultOptions.account.address],
+      }),
+    );
+  };
+}
+
+describe('AllowList', () => {
+  test('can automatically instantiate SimpleAllowList given an address', async () => {
+    const _allowList = await loadFixture(freshAllowList(fixtures));
+    expect(
+      await allowListFromAddress(
+        defaultOptions,
+        _allowList.assertValidAddress(),
+      ),
+    ).toBeInstanceOf(SimpleAllowList);
+  });
+
+  test('can automatically instantiate SimpleDenyList given an address', async () => {
+    const _allowList = await loadFixture(freshDenyList(fixtures));
+    expect(
+      await allowListFromAddress(
+        defaultOptions,
+        _allowList.assertValidAddress(),
+      ),
+    ).toBeInstanceOf(SimpleDenyList);
+  });
+});

package/src/AllowLists/AllowList.ts

@@ -0,0 +1,62 @@
+import { aAllowListAbi } from '@boostxyz/evm';
+import {
+  ASimpleAllowList,
+  ASimpleDenyList,
+} 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 { OpenAllowList } from './OpenAllowList';
+import { SimpleAllowList } from './SimpleAllowList';
+import { SimpleDenyList } from './SimpleDenyList';
+
+export { OpenAllowList, SimpleAllowList, SimpleDenyList };
+
+/**
+ * A union type representing all valid protocol AllowList implementations
+ *
+ * @export
+ * @typedef {AllowList}
+ */
+export type AllowList = OpenAllowList | SimpleAllowList | SimpleDenyList;
+
+/**
+ * A map of AllowList component interfaces to their constructors.
+ *
+ * @type {{ "0x2bc9016b": SimpleAllowList; "0x9d585f63": SimpleDenyList; }}
+ */
+export const AllowListByComponentInterface = {
+  [ASimpleAllowList as Hex]: SimpleAllowList,
+  [ASimpleDenyList as Hex]: SimpleDenyList,
+};
+
+/**
+ * A function that will read a contract's component interface using `getComponentInterface` and return the correct instantiated instance.
+ * This function will never return an instance of {@link OpenAllowList} because it has the same component interface as {@link SimpleDenyList}
+ *
+ * @export
+ * @async
+ * @param {DeployableOptions} options
+ * @param {Address} address
+ * @returns {Promise<SimpleAllowList | SimpleDenyList>}
+ * @throws {@link InvalidComponentInterfaceError}
+ */
+export async function allowListFromAddress(
+  options: DeployableOptions,
+  address: Address,
+) {
+  const interfaceId = (await readContract(options.config, {
+    abi: aAllowListAbi,
+    functionName: 'getComponentInterface',
+    address,
+  })) as keyof typeof AllowListByComponentInterface;
+  const Ctor = AllowListByComponentInterface[interfaceId];
+  if (!Ctor) {
+    throw new InvalidComponentInterfaceError(
+      Object.keys(AllowListByComponentInterface) as Hex[],
+      interfaceId as Hex,
+    );
+  }
+  return new Ctor(options, address) as SimpleDenyList | SimpleAllowList;
+}

package/src/AllowLists/OpenAllowList.test.ts

@@ -0,0 +1,40 @@
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { isAddress, zeroAddress } from 'viem';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { accounts } from '@boostxyz/test/accounts';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+} from '@boostxyz/test/helpers';
+import { OpenAllowList } from './OpenAllowList';
+
+let fixtures: Fixtures;
+
+beforeAll(async () => {
+  fixtures = await loadFixture(deployFixtures(defaultOptions));
+});
+
+function freshOpenAllowList(fixtures: Fixtures) {
+  return function freshOpenAllowList() {
+    return fixtures.registry.initialize(
+      crypto.randomUUID(),
+      new fixtures.bases.OpenAllowList(defaultOptions),
+    );
+  };
+}
+
+describe('OpenAllowList', () => {
+  test('can successfully be deployed', async () => {
+    const denyList = new OpenAllowList(defaultOptions);
+    await denyList.deploy();
+    expect(isAddress(denyList.assertValidAddress())).toBe(true);
+  });
+
+  test('allows anyone', async () => {
+    const denyList = await loadFixture(freshOpenAllowList(fixtures));
+    expect(await denyList.isAllowed(defaultOptions.account.address)).toBe(true);
+    expect(await denyList.isAllowed(zeroAddress)).toBe(true);
+    expect(await denyList.isAllowed(accounts.at(1)!.account)).toBe(true);
+  });
+});

package/src/AllowLists/OpenAllowList.ts

@@ -0,0 +1,45 @@
+import { simpleDenyListAbi } from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/allowlists/SimpleDenyList.sol/SimpleDenyList.json';
+import { type Hex, zeroAddress } from 'viem';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import {
+  SimpleDenyList,
+  type SimpleDenyListPayload,
+  prepareSimpleDenyListPayload,
+} from './SimpleDenyList';
+
+export const openAllowListAbi = simpleDenyListAbi;
+
+/**
+ * A simple AllowList, extending {@link DenyList}, that is ownerless and allows anyone to claim.
+ *
+ * @export
+ * @class OpenAllowList
+ * @typedef {OpenAllowList}
+ * @extends {DeployableTarget<OpenAllowListPayload>}
+ */
+export class OpenAllowList extends SimpleDenyList<undefined> {
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @param {?SimpleDenyListPayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: SimpleDenyListPayload,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [_, options] = this.validateDeploymentConfig({}, _options);
+    return {
+      abi: openAllowListAbi,
+      bytecode: bytecode as Hex,
+      args: [prepareSimpleDenyListPayload({ owner: zeroAddress, denied: [] })],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}

package/src/AllowLists/SimpleAllowList.test.ts

@@ -0,0 +1,52 @@
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { isAddress, zeroAddress } from 'viem';
+import { beforeAll, describe, expect, test } from 'vitest';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+} from '@boostxyz/test/helpers';
+import { SimpleAllowList } from './SimpleAllowList';
+
+let fixtures: Fixtures;
+
+beforeAll(async () => {
+  fixtures = await loadFixture(deployFixtures(defaultOptions));
+});
+
+function freshAllowList(fixtures: Fixtures) {
+  return function freshAllowList() {
+    return fixtures.registry.initialize(
+      crypto.randomUUID(),
+      fixtures.core.SimpleAllowList({
+        owner: defaultOptions.account.address,
+        allowed: [defaultOptions.account.address],
+      }),
+    );
+  };
+}
+
+describe('SimpleAllowList', () => {
+  test('can successfully be deployed', async () => {
+    const allowList = new SimpleAllowList(defaultOptions, {
+      owner: defaultOptions.account.address,
+      allowed: [],
+    });
+    await allowList.deploy();
+    expect(isAddress(allowList.assertValidAddress())).toBe(true);
+  });
+
+  test('can check is allowed', async () => {
+    const allowList = await loadFixture(freshAllowList(fixtures));
+    expect(await allowList.isAllowed(defaultOptions.account.address)).toBe(
+      true,
+    );
+    expect(await allowList.isAllowed(zeroAddress)).toBe(false);
+  });
+
+  test('can set allowed', async () => {
+    const allowList = await loadFixture(freshAllowList(fixtures));
+    await allowList.setAllowed([zeroAddress], [true]);
+    expect(await allowList.isAllowed(zeroAddress)).toBe(true);
+  });
+});

package/src/AllowLists/SimpleAllowList.ts

@@ -0,0 +1,262 @@
+import {
+  readSimpleAllowListIsAllowed,
+  readSimpleAllowListOwner,
+  simpleAllowListAbi,
+  simulateSimpleAllowListSetAllowed,
+  writeSimpleAllowListSetAllowed,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/allowlists/SimpleAllowList.sol/SimpleAllowList.json';
+import { getAccount } from '@wagmi/core';
+import {
+  type Address,
+  type ContractEventName,
+  type Hex,
+  encodeAbiParameters,
+  zeroAddress,
+  zeroHash,
+} from 'viem';
+import { SimpleAllowList as SimpleAllowListBases } from '../../dist/deployments.json';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import {
+  DeployableTargetWithRBAC,
+  Roles,
+} from '../Deployable/DeployableTargetWithRBAC';
+import { DeployableUnknownOwnerProvidedError } from '../errors';
+import {
+  type GenericLog,
+  type ReadParams,
+  RegistryType,
+  type WriteParams,
+} from '../utils';
+
+export { simpleAllowListAbi };
+
+/**
+ * Object representation of a {@link SimpleAllowList} initialization payload.
+ *
+ * @export
+ * @interface SimpleAllowListPayload
+ * @typedef {SimpleAllowListPayload}
+ */
+export interface SimpleAllowListPayload {
+  /**
+   * The allow list's owner, given the {@link LIST_MANAGER_ROLE} role.
+   *
+   * @type {Address}
+   */
+  owner: Address;
+  /**
+   * List of allowed addresses.
+   *
+   * @type {Address[]}
+   */
+  allowed: Address[];
+}
+
+/**
+ * A generic `viem.Log` event with support for `SimpleAllowList` event types.
+ *
+ * @export
+ * @typedef {SimpleAllowListLog}
+ * @template {ContractEventName<
+ *     typeof simpleAllowListAbi
+ *   >} [event=ContractEventName<typeof simpleAllowListAbi>]
+ */
+export type SimpleAllowListLog<
+  event extends ContractEventName<
+    typeof simpleAllowListAbi
+  > = ContractEventName<typeof simpleAllowListAbi>,
+> = GenericLog<typeof simpleAllowListAbi, event>;
+
+/**
+ * A constant representing the list manager's role
+ *
+ * @deprecated use {@link Roles} instead
+ * @type {1n}
+ */
+export const LIST_MANAGER_ROLE = Roles.MANAGER;
+/**
+ * A simple implementation of an AllowList that checks if a user is authorized based on a list of allowed addresses
+ *
+ * @export
+ * @class SimpleAllowList
+ * @typedef {SimpleAllowList}
+ * @extends {DeployableTargetWithRBAC<SimpleAllowListPayload>}
+ */
+export class SimpleAllowList extends DeployableTargetWithRBAC<
+  SimpleAllowListPayload,
+  typeof simpleAllowListAbi
+> {
+  public override readonly abi = simpleAllowListAbi;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Record<number, Address>}
+   */
+  public static override bases: Record<number, Address> = {
+    ...(SimpleAllowListBases as Record<number, Address>),
+  };
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.ALLOW_LIST;
+
+  /**
+   * Retrieves the owner
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Address>} - The address of the owner
+   */
+  public async owner(
+    params?: ReadParams<typeof simpleAllowListAbi, 'owner'>,
+  ): Promise<Address> {
+    return await readSimpleAllowListOwner(this._config, {
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+      address: this.assertValidAddress(),
+      args: [],
+    });
+  }
+
+  /**
+   * Check if a user is authorized.
+   *
+   * @public
+   * @async
+   * @param {Address} address - The address of the user
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} - True if the user is authorized
+   */
+  public async isAllowed(
+    address: Address,
+    params?: ReadParams<typeof simpleAllowListAbi, 'setAllowed'>,
+  ): Promise<boolean> {
+    return await readSimpleAllowListIsAllowed(this._config, {
+      address: this.assertValidAddress(),
+      args: [address, zeroHash],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Set the allowed status of a user. The length of the `users_` and `allowed_` arrays must be the same.
+   * This function can only be called by the owner
+   *
+   * @public
+   * @async
+   * @param {Address[]} addresses - The list of users to update
+   * @param {boolean[]} allowed - The allowed status of each user
+   * @param {?ReadParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async setAllowed(
+    addresses: Address[],
+    allowed: boolean[],
+    params?: WriteParams<typeof simpleAllowListAbi, 'setAllowed'>,
+  ) {
+    return await this.awaitResult(
+      this.setAllowedRaw(addresses, allowed, params),
+    );
+  }
+
+  /**
+   * Set the allowed status of a user. The length of the `users_` and `allowed_` arrays must be the same.
+   * This function can only be called by the owner
+   *
+   * @public
+   * @async
+   * @param {Address[]} addresses - The list of users to update
+   * @param {boolean[]} allowed - The allowed status of each user
+   * @param {?ReadParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async setAllowedRaw(
+    addresses: Address[],
+    allowed: boolean[],
+    params?: ReadParams<typeof simpleAllowListAbi, 'setAllowed'>,
+  ) {
+    const { request, result } = await simulateSimpleAllowListSetAllowed(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [addresses, allowed],
+        ...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 writeSimpleAllowListSetAllowed(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @param {?SimpleAllowListPayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: SimpleAllowListPayload,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [payload, options] = this.validateDeploymentConfig(
+      _payload,
+      _options,
+    );
+    if (!payload.owner || payload.owner === zeroAddress) {
+      const owner = options.account
+        ? options.account.address
+        : options.config
+          ? getAccount(options.config).address
+          : this._account?.address;
+      if (owner) {
+        payload.owner = owner;
+      } else {
+        throw new DeployableUnknownOwnerProvidedError();
+      }
+    }
+    return {
+      abi: simpleAllowListAbi,
+      bytecode: bytecode as Hex,
+      args: [prepareSimpleAllowListPayload(payload)],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}
+
+/**
+ * Given a {@link SimpleAllowListPayload}, properly encode the initialization payload.
+ *
+ * @param {SimpleAllowListPayload} param0
+ * @param {Address} param0.owner - The allow list's owner, given the {@link LIST_MANAGER_ROLE} role.
+ * @param {Address[]} param0.allowed - List of allowed addresses.
+ * @returns {Hex}
+ */
+export function prepareSimpleAllowListPayload({
+  owner,
+  allowed,
+}: SimpleAllowListPayload) {
+  return encodeAbiParameters(
+    [
+      { type: 'address', name: 'owner' },
+      { type: 'address[]', name: 'allowed' },
+    ],
+    [owner, allowed],
+  );
+}

package/src/AllowLists/SimpleDenyList.test.ts

@@ -0,0 +1,52 @@
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { isAddress, zeroAddress } from 'viem';
+import { beforeAll, describe, expect, test } from 'vitest';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+} from '@boostxyz/test/helpers';
+import { SimpleDenyList } from './SimpleDenyList';
+
+let fixtures: Fixtures;
+
+beforeAll(async () => {
+  fixtures = await loadFixture(deployFixtures(defaultOptions));
+});
+
+function freshDenyList(fixtures: Fixtures) {
+  return function freshDenyList() {
+    return fixtures.registry.initialize(
+      crypto.randomUUID(),
+      fixtures.core.SimpleDenyList({
+        owner: defaultOptions.account.address,
+        denied: [defaultOptions.account.address],
+      }),
+    );
+  };
+}
+
+describe('SimpleDenyList', () => {
+  test('can successfully be deployed', async () => {
+    const denyList = new SimpleDenyList(defaultOptions, {
+      owner: defaultOptions.account.address,
+      denied: [],
+    });
+    await denyList.deploy();
+    expect(isAddress(denyList.assertValidAddress())).toBe(true);
+  });
+
+  test('can check is denied', async () => {
+    const denyList = await loadFixture(freshDenyList(fixtures));
+    expect(await denyList.isAllowed(defaultOptions.account.address)).toBe(
+      false,
+    );
+    expect(await denyList.isAllowed(zeroAddress)).toBe(true);
+  });
+
+  test('can set denied', async () => {
+    const denyList = await loadFixture(freshDenyList(fixtures));
+    await denyList.setDenied([zeroAddress], [true]);
+    expect(await denyList.isAllowed(zeroAddress)).toBe(false);
+  });
+});