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

package/src/AllowLists/AllowList.test.ts

@@ -4,7 +4,7 @@ import {
   type Fixtures,
   defaultOptions,
   deployFixtures,
-} from '../../test/helpers';
+} from '@boostxyz/test/helpers';
 import {
   SimpleAllowList,
   SimpleDenyList,
@@ -14,14 +14,14 @@ import {
 let fixtures: Fixtures;
 
 beforeAll(async () => {
-  fixtures = await loadFixture(deployFixtures);
+  fixtures = await loadFixture(deployFixtures(defaultOptions));
 });
 
 function freshAllowList(fixtures: Fixtures) {
   return function freshAllowList() {
-    return fixtures.registry.clone(
+    return fixtures.registry.initialize(
       crypto.randomUUID(),
-      new fixtures.bases.SimpleAllowList(defaultOptions, {
+      fixtures.core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),
@@ -31,9 +31,9 @@ function freshAllowList(fixtures: Fixtures) {
 
 function freshDenyList(fixtures: Fixtures) {
   return function freshDenyList() {
-    return fixtures.registry.clone(
+    return fixtures.registry.initialize(
       crypto.randomUUID(),
-      new fixtures.bases.SimpleDenyList(defaultOptions, {
+      fixtures.core.SimpleDenyList({
         owner: defaultOptions.account.address,
         denied: [defaultOptions.account.address],
       }),
@@ -52,7 +52,7 @@ describe('AllowList', () => {
     ).toBeInstanceOf(SimpleAllowList);
   });
 
-  test('can automatically instantiate SimpleAllowList given an address', async () => {
+  test('can automatically instantiate SimpleDenyList given an address', async () => {
     const _allowList = await loadFixture(freshDenyList(fixtures));
     expect(
       await allowListFromAddress(

package/src/AllowLists/AllowList.ts

@@ -7,10 +7,11 @@ 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 { SimpleAllowList, SimpleDenyList };
+export { OpenAllowList, SimpleAllowList, SimpleDenyList };
 
 /**
  * A union type representing all valid protocol AllowList implementations
@@ -18,7 +19,7 @@ export { SimpleAllowList, SimpleDenyList };
  * @export
  * @typedef {AllowList}
  */
-export type AllowList = SimpleAllowList | SimpleDenyList;
+export type AllowList = OpenAllowList | SimpleAllowList | SimpleDenyList;
 
 /**
  * A map of AllowList component interfaces to their constructors.
@@ -32,6 +33,7 @@ export const AllowListByComponentInterface = {
 
 /**
  * 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
@@ -56,5 +58,5 @@ export async function allowListFromAddress(
       interfaceId as Hex,
     );
   }
-  return new Ctor(options, address);
+  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

@@ -5,20 +5,20 @@ import {
   type Fixtures,
   defaultOptions,
   deployFixtures,
-} from '../../test/helpers';
+} from '@boostxyz/test/helpers';
 import { SimpleAllowList } from './SimpleAllowList';
 
 let fixtures: Fixtures;
 
 beforeAll(async () => {
-  fixtures = await loadFixture(deployFixtures);
+  fixtures = await loadFixture(deployFixtures(defaultOptions));
 });
 
 function freshAllowList(fixtures: Fixtures) {
   return function freshAllowList() {
-    return fixtures.registry.clone(
+    return fixtures.registry.initialize(
       crypto.randomUUID(),
-      new fixtures.bases.SimpleAllowList(defaultOptions, {
+      fixtures.core.SimpleAllowList({
         owner: defaultOptions.account.address,
         allowed: [defaultOptions.account.address],
       }),

package/src/AllowLists/SimpleAllowList.ts

@@ -1,9 +1,8 @@
 import {
   readSimpleAllowListIsAllowed,
+  readSimpleAllowListOwner,
   simpleAllowListAbi,
-  simulateSimpleAllowListGrantRoles,
   simulateSimpleAllowListSetAllowed,
-  writeSimpleAllowListGrantRoles,
   writeSimpleAllowListSetAllowed,
 } from '@boostxyz/evm';
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/allowlists/SimpleAllowList.sol/SimpleAllowList.json';
@@ -12,26 +11,50 @@ 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 { DeployableTarget } from '../Deployable/DeployableTarget';
+import {
+  DeployableTargetWithRBAC,
+  Roles,
+} from '../Deployable/DeployableTargetWithRBAC';
 import { DeployableUnknownOwnerProvidedError } from '../errors';
 import {
   type GenericLog,
   type ReadParams,
   RegistryType,
-  type SimpleAllowListPayload,
   type WriteParams,
-  prepareSimpleAllowListPayload,
 } from '../utils';
 
 export { simpleAllowListAbi };
-export type { SimpleAllowListPayload };
+
+/**
+ * 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.
@@ -51,18 +74,19 @@ export type SimpleAllowListLog<
 /**
  * A constant representing the list manager's role
  *
- * @type {2n}
+ * @deprecated use {@link Roles} instead
+ * @type {1n}
  */
-export const LIST_MANAGER_ROLE = 2n;
+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 {DeployableTarget<SimpleAllowListPayload>}
+ * @extends {DeployableTargetWithRBAC<SimpleAllowListPayload>}
  */
-export class SimpleAllowList extends DeployableTarget<
+export class SimpleAllowList extends DeployableTargetWithRBAC<
   SimpleAllowListPayload,
   typeof simpleAllowListAbi
 > {
@@ -72,10 +96,11 @@ export class SimpleAllowList extends DeployableTarget<
    *
    * @public
    * @static
-   * @type {Address}
+   * @type {Record<number, Address>}
    */
-  public static override base: Address = import.meta.env
-    .VITE_SIMPLE_ALLOWLIST_BASE;
+  public static override bases: Record<number, Address> = {
+    ...(SimpleAllowListBases as Record<number, Address>),
+  };
   /**
    * @inheritdoc
    *
@@ -85,13 +110,33 @@ export class SimpleAllowList extends DeployableTarget<
    */
   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<typeof simpleAllowListAbi, 'setAllowed'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<boolean>} - True if the user is authorized
    */
   public async isAllowed(
@@ -115,7 +160,7 @@ export class SimpleAllowList extends DeployableTarget<
    * @async
    * @param {Address[]} addresses - The list of users to update
    * @param {boolean[]} allowed - The allowed status of each user
-   * @param {?ReadParams<typeof simpleAllowListAbi, 'setAllowed'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<void>}
    */
   public async setAllowed(
@@ -123,7 +168,9 @@ export class SimpleAllowList extends DeployableTarget<
     allowed: boolean[],
     params?: WriteParams<typeof simpleAllowListAbi, 'setAllowed'>,
   ) {
-    return this.awaitResult(this.setAllowedRaw(addresses, allowed, params));
+    return await this.awaitResult(
+      this.setAllowedRaw(addresses, allowed, params),
+    );
   }
 
   /**
@@ -134,8 +181,8 @@ export class SimpleAllowList extends DeployableTarget<
    * @async
    * @param {Address[]} addresses - The list of users to update
    * @param {boolean[]} allowed - The allowed status of each user
-   * @param {?ReadParams<typeof simpleAllowListAbi, 'setAllowed'>} [params]
-   * @returns {Promise<void>}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
    */
   public async setAllowedRaw(
     addresses: Address[],
@@ -156,53 +203,6 @@ export class SimpleAllowList extends DeployableTarget<
     return { hash, result };
   }
 
-  /**
-   * Allows the owner to grant `user` `roles`.
-   *
-   * @public
-   * @async
-   * @param {Address} address
-   * @param {bigint} role
-   * @param {?ReadParams<typeof simpleAllowListAbi, 'grantRoles'>} [params]
-   * @returns {Promise<void>}
-   */
-  public async grantRoles(
-    address: Address,
-    role: bigint,
-    params?: WriteParams<typeof simpleAllowListAbi, 'grantRoles'>,
-  ) {
-    return this.awaitResult(this.grantRolesRaw(address, role, params));
-  }
-
-  /**
-   * Allows the owner to grant `user` `roles`.
-   *
-   * @public
-   * @async
-   * @param {Address} address
-   * @param {bigint} role
-   * @param {?ReadParams<typeof simpleAllowListAbi, 'grantRoles'>} [params]
-   * @returns {Promise<void>}
-   */
-  public async grantRolesRaw(
-    address: Address,
-    role: bigint,
-    params?: ReadParams<typeof simpleAllowListAbi, 'grantRoles'>,
-  ) {
-    const { request, result } = await simulateSimpleAllowListGrantRoles(
-      this._config,
-      {
-        address: this.assertValidAddress(),
-        args: [address, role],
-        ...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 writeSimpleAllowListGrantRoles(this._config, request);
-    return { hash, result };
-  }
-
   /**
    * @inheritdoc
    *
@@ -239,3 +239,24 @@ export class SimpleAllowList extends DeployableTarget<
     };
   }
 }
+
+/**
+ * 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

@@ -5,20 +5,20 @@ import {
   type Fixtures,
   defaultOptions,
   deployFixtures,
-} from '../../test/helpers';
+} from '@boostxyz/test/helpers';
 import { SimpleDenyList } from './SimpleDenyList';
 
 let fixtures: Fixtures;
 
 beforeAll(async () => {
-  fixtures = await loadFixture(deployFixtures);
+  fixtures = await loadFixture(deployFixtures(defaultOptions));
 });
 
 function freshDenyList(fixtures: Fixtures) {
   return function freshDenyList() {
-    return fixtures.registry.clone(
+    return fixtures.registry.initialize(
       crypto.randomUUID(),
-      new fixtures.bases.SimpleDenyList(defaultOptions, {
+      fixtures.core.SimpleDenyList({
         owner: defaultOptions.account.address,
         denied: [defaultOptions.account.address],
       }),