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

package/src/AllowLists/SimpleAllowList.ts

@@ -0,0 +1,240 @@
+import {
+  readSimpleAllowListIsAllowed,
+  simpleAllowListAbi,
+  simulateSimpleAllowListGrantRoles,
+  simulateSimpleAllowListSetAllowed,
+  writeSimpleAllowListGrantRoles,
+  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,
+  zeroAddress,
+  zeroHash,
+} from 'viem';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import { DeployableUnknownOwnerProvidedError } from '../errors';
+import {
+  type GenericLog,
+  type ReadParams,
+  RegistryType,
+  type SimpleAllowListPayload,
+  prepareSimpleAllowListPayload,
+} from '../utils';
+
+export { simpleAllowListAbi };
+export type { SimpleAllowListPayload };
+
+/**
+ * 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
+ *
+ * @type {2n}
+ */
+export const LIST_MANAGER_ROLE = 2n;
+/**
+ * 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>}
+ */
+export class SimpleAllowList extends DeployableTarget<
+  SimpleAllowListPayload,
+  typeof simpleAllowListAbi
+> {
+  public override readonly abi = simpleAllowListAbi;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Address}
+   */
+  public static override base: Address = import.meta.env
+    .VITE_SIMPLE_ALLOWLIST_BASE;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.ALLOW_LIST;
+
+  /**
+   * Check if a user is authorized.
+   *
+   * @public
+   * @async
+   * @param {Address} address - The address of the user
+   * @param {?ReadParams<typeof simpleAllowListAbi, 'setAllowed'>} [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<typeof simpleAllowListAbi, 'setAllowed'>} [params]
+   * @returns {Promise<void>}
+   */
+  public async setAllowed(
+    addresses: Address[],
+    allowed: boolean[],
+    params?: ReadParams<typeof simpleAllowListAbi, 'setAllowed'>,
+  ) {
+    return 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<typeof simpleAllowListAbi, 'setAllowed'>} [params]
+   * @returns {Promise<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 };
+  }
+
+  /**
+   * 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?: ReadParams<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
+   *
+   * @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),
+    };
+  }
+}

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 '../../test/helpers';
+import { SimpleDenyList } from './SimpleDenyList';
+
+let fixtures: Fixtures;
+
+beforeAll(async () => {
+  fixtures = await loadFixture(deployFixtures);
+});
+
+function freshDenyList(fixtures: Fixtures) {
+  return function freshDenyList() {
+    return fixtures.registry.clone(
+      crypto.randomUUID(),
+      new fixtures.bases.SimpleDenyList(defaultOptions, {
+        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);
+  });
+});

package/src/AllowLists/SimpleDenyList.ts

@@ -0,0 +1,289 @@
+import {
+  readSimpleDenyListIsAllowed,
+  simpleDenyListAbi,
+  simulateSimpleDenyListSetDenied,
+  writeSimpleDenyListSetDenied,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/allowlists/SimpleDenyList.sol/SimpleDenyList.json';
+import { getAccount } from '@wagmi/core';
+import {
+  type Address,
+  type ContractEventName,
+  type Hex,
+  zeroAddress,
+  zeroHash,
+} from 'viem';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import { DeployableUnknownOwnerProvidedError } from '../errors';
+import {
+  type GenericLog,
+  type ReadParams,
+  RegistryType,
+  type SimpleDenyListPayload,
+  type WriteParams,
+  prepareSimpleDenyListPayload,
+} from '../utils';
+
+export { simpleDenyListAbi };
+export type { SimpleDenyListPayload };
+
+/**
+ * A generic `viem.Log` event with support for `SimpleDenyList` event types.
+ *
+ * @export
+ * @typedef {SimpleDenyListLog}
+ * @template {ContractEventName<typeof simpleDenyListAbi>} [event=ContractEventName<
+ *     typeof simpleDenyListAbi
+ *   >]
+ */
+export type SimpleDenyListLog<
+  event extends ContractEventName<typeof simpleDenyListAbi> = ContractEventName<
+    typeof simpleDenyListAbi
+  >,
+> = GenericLog<typeof simpleDenyListAbi, event>;
+
+/**
+ * A simple implementation of an AllowList that implicitly allows all addresses except those explicitly added to the deny list
+ *
+ * @export
+ * @class SimpleDenyList
+ * @typedef {SimpleDenyList}
+ * @extends {DeployableTarget<SimpleDenyListPayload>}
+ */
+export class SimpleDenyList extends DeployableTarget<
+  SimpleDenyListPayload,
+  typeof simpleDenyListAbi
+> {
+  public override readonly abi = simpleDenyListAbi;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Address}
+   */
+  public static override base: Address = import.meta.env
+    .VITE_SIMPLE_DENYLIST_BASE;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.ALLOW_LIST;
+
+  /**
+   * Check if a user is authorized (i.e. not denied)
+   *
+   * @public
+   * @async
+   * @param {Address} address - The address of the user
+   * @param {?ReadParams<typeof simpleDenyListAbi, 'isAllowed'>} [params]
+   * @returns {Promise<boolean>} - True if the user is authorized
+   */
+  public async isAllowed(
+    address: Address,
+    params?: ReadParams<typeof simpleDenyListAbi, 'isAllowed'>,
+  ): Promise<boolean> {
+    return await readSimpleDenyListIsAllowed(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 denied status of a user. The length of the `users_` and `denied_` 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 denied status of each user
+   * @param {?WriteParams<typeof simpleDenyListAbi, 'setDenied'>} [params]
+   * @returns {unknown}
+   */
+  public async setDenied(
+    addresses: Address[],
+    allowed: boolean[],
+    params?: WriteParams<typeof simpleDenyListAbi, 'setDenied'>,
+  ) {
+    return this.awaitResult(this.setDeniedRaw(addresses, allowed, params));
+  }
+
+  /**
+   * Set the denied status of a user. The length of the `users_` and `denied_` 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 denied status of each user
+   * @param {?WriteParams<typeof simpleDenyListAbi, 'setDenied'>} [params]
+   * @returns {unknown}
+   */
+  public async setDeniedRaw(
+    addresses: Address[],
+    allowed: boolean[],
+    params?: WriteParams<typeof simpleDenyListAbi, 'setDenied'>,
+  ) {
+    const { request, result } = await simulateSimpleDenyListSetDenied(
+      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 writeSimpleDenyListSetDenied(this._config, request);
+    return { hash, result };
+  }
+
+  // /**
+  //  * A typed wrapper for (viem.getLogs)[https://viem.sh/docs/actions/public/getLogs#getlogs].
+  //  * Accepts `eventName` and `eventNames` as optional parameters to narrow the returned log types.
+  //  * @example
+  //  * ```ts
+  //  * const logs = contract.getLogs({ eventName: 'EventName' })
+  //  * const logs = contract.getLogs({ eventNames: ['EventName'] })
+  //  * ```
+  //  * @public
+  //  * @async
+  //  * @template {ContractEventName<typeof simpleDenyListAbi>} event
+  //  * @template {ExtractAbiEvent<
+  //  *       typeof simpleDenyListAbi,
+  //  *       event
+  //  *     >} [abiEvent=ExtractAbiEvent<typeof simpleDenyListAbi, event>]
+  //  * @param {?Omit<
+  //  *       GetLogsParams<typeof simpleDenyListAbi, event, abiEvent, abiEvent[]>,
+  //  *       'event' | 'events'
+  //  *     > & {
+  //  *       eventName?: event;
+  //  *       eventNames?: event[];
+  //  *     }} [params]
+  //  * @returns {Promise<GetLogsReturnType<abiEvent, abiEvent[]>>}
+  //  */
+  // public async getLogs<
+  //   event extends ContractEventName<typeof simpleDenyListAbi>,
+  //   const abiEvent extends ExtractAbiEvent<
+  //     typeof simpleDenyListAbi,
+  //     event
+  //   > = ExtractAbiEvent<typeof simpleDenyListAbi, event>,
+  // >(
+  //   params?: Omit<
+  //     GetLogsParams<typeof simpleDenyListAbi, event, abiEvent, abiEvent[]>,
+  //     'event' | 'events'
+  //   > & {
+  //     eventName?: event;
+  //     eventNames?: event[];
+  //   },
+  // ): Promise<GetLogsReturnType<abiEvent, abiEvent[]>> {
+  //   return getLogs(this._config.getClient({ chainId: params?.chainId }), {
+  //     // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wag
+  //     ...(params as any),
+  //     ...(params?.eventName
+  //       ? {
+  //           event: getAbiItem({
+  //             abi: simpleDenyListAbi,
+  //             name: params.eventName,
+  //             // biome-ignore lint/suspicious/noExplicitAny: awkward abi intersection issue
+  //           } as any),
+  //         }
+  //       : {}),
+  //     ...(params?.eventNames
+  //       ? {
+  //           events: params.eventNames.map((name) =>
+  //             getAbiItem({
+  //               abi: simpleDenyListAbi,
+  //               name,
+  //               // biome-ignore lint/suspicious/noExplicitAny: awkward abi intersection issue
+  //             } as any),
+  //           ),
+  //         }
+  //       : {}),
+  //     address: this.assertValidAddress(),
+  //   });
+  // }
+
+  // /**
+  //  * A typed wrapper for `wagmi.watchContractEvent`
+  //  *
+  //  * @public
+  //  * @async
+  //  * @template {ContractEventName<typeof simpleDenyListAbi>} event
+  //  * @param {(log: SimpleDenyListLog<event>) => unknown} cb
+  //  * @param {?WatchParams<typeof simpleDenyListAbi, event> & {
+  //  *       eventName?: event;
+  //  *     }} [params]
+  //  * @returns {unknown, params?: any) => unknown} Unsubscribe function
+  //  */
+  // public async subscribe<
+  //   event extends ContractEventName<typeof simpleDenyListAbi>,
+  // >(
+  //   cb: (log: SimpleDenyListLog<event>) => unknown,
+  //   params?: WatchParams<typeof simpleDenyListAbi, event> & {
+  //     eventName?: event;
+  //   },
+  // ) {
+  //   return watchContractEvent<
+  //     typeof this._config,
+  //     (typeof this._config)['chains'][number]['id'],
+  //     typeof simpleDenyListAbi,
+  //     event
+  //   >(this._config, {
+  //     // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+  //     ...(params as any),
+  //     eventName: params?.eventName,
+  //     abi: simpleDenyListAbi,
+  //     address: this.assertValidAddress(),
+  //     onLogs: (logs) => {
+  //       for (let l of logs) {
+  //         cb(l as unknown as SimpleDenyListLog<event>);
+  //       }
+  //     },
+  //   });
+  // }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @param {?SimpleDenyListPayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: SimpleDenyListPayload,
+    _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: simpleDenyListAbi,
+      bytecode: bytecode as Hex,
+      args: [prepareSimpleDenyListPayload(payload)],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}

package/src/Auth/Auth.ts

@@ -0,0 +1,11 @@
+import { PassthroughAuth } from './PassthroughAuth';
+
+export { PassthroughAuth };
+
+/**
+ * A union type representing all valid protocol Auth implementations
+ *
+ * @export
+ * @typedef {Auth}
+ */
+export type Auth = PassthroughAuth;

package/src/Auth/PassthroughAuth.test.ts

@@ -0,0 +1,12 @@
+import { zeroAddress } from 'viem';
+import { describe, expect, test } from 'vitest';
+import { defaultOptions } from '../../test/helpers';
+import { PassthroughAuth } from './PassthroughAuth';
+
+describe('PassthroughAuth', () => {
+  test('can successfully be deployed', async () => {
+    const auth = new PassthroughAuth(defaultOptions);
+    await auth.deploy();
+    expect(await auth.isAuthorized(zeroAddress)).toBe(true);
+  });
+});

package/src/Auth/PassthroughAuth.ts

@@ -0,0 +1,80 @@
+import {
+  passthroughAuthAbi,
+  readPassthroughAuthIsAuthorized,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/auth/PassthroughAuth.sol/PassthroughAuth.json';
+import type { Address, ContractEventName, Hex } from 'viem';
+import {
+  Deployable,
+  type DeployableOptions,
+  type GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import type { GenericLog, ReadParams } from '../utils';
+
+export { passthroughAuthAbi };
+
+/**
+ * A generic `viem.Log` event with support for `PassthroughAuth` event types.
+ *
+ * @export
+ * @typedef {PassthroughAuthLog}
+ * @template {ContractEventName<
+ *     typeof passthroughAuthAbi
+ *   >} [event=ContractEventName<typeof passthroughAuthAbi>]
+ */
+export type PassthroughAuthLog<
+  event extends ContractEventName<
+    typeof passthroughAuthAbi
+  > = ContractEventName<typeof passthroughAuthAbi>,
+> = GenericLog<typeof passthroughAuthAbi, event>;
+
+/**
+ *  A simple implementation of a Validator that verifies a given signature and checks the recovered address against a set of authorized signers
+ *
+ * @export
+ * @class PassthroughAuth
+ * @typedef {PassthroughAuth}
+ * @extends {DeployableTarget<PassthroughAuthPayload>}
+ */
+export class PassthroughAuth extends Deployable<
+  // biome-ignore lint/suspicious/noExplicitAny: takes no parameters
+  any,
+  typeof passthroughAuthAbi
+> {
+  public override readonly abi = passthroughAuthAbi;
+
+  public async isAuthorized(
+    address: Address,
+    params?: ReadParams<typeof passthroughAuthAbi, 'isAuthorized'>,
+  ) {
+    return readPassthroughAuthIsAuthorized(this._config, {
+      address: this.assertValidAddress(),
+      args: [address],
+      // 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 {?PassthroughAuthPayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: never,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [_, options] = this.validateDeploymentConfig({}, _options);
+    return {
+      abi: passthroughAuthAbi,
+      bytecode: bytecode as Hex,
+      // biome-ignore lint/suspicious/noExplicitAny: <takes no payload>
+      args: [] as any,
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}