@boostxyz/sdk 0.0.0-alpha.15 → 0.0.0-alpha.17

package/src/AllowLists/SimpleAllowList.ts

@@ -2,9 +2,7 @@ import {
   readSimpleAllowListIsAllowed,
   readSimpleAllowListOwner,
   simpleAllowListAbi,
-  simulateSimpleAllowListGrantRoles,
   simulateSimpleAllowListSetAllowed,
-  writeSimpleAllowListGrantRoles,
   writeSimpleAllowListSetAllowed,
 } from '@boostxyz/evm';
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/allowlists/SimpleAllowList.sol/SimpleAllowList.json';
@@ -22,7 +20,10 @@ 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,
@@ -73,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
 > {
@@ -108,6 +110,26 @@ export class SimpleAllowList extends DeployableTarget<
    */
   public static override registryType: RegistryType = RegistryType.ALLOW_LIST;
 
+  /**
+   * Retrieves the owner
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof simpleAllowListAbi, 'owner'>} [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.
    *
@@ -181,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 await 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
    *

package/src/AllowLists/SimpleDenyList.ts

@@ -1,4 +1,5 @@
 import {
+  readSimpleAllowListOwner,
   readSimpleDenyListIsAllowed,
   simpleDenyListAbi,
   simulateSimpleDenyListSetDenied,
@@ -19,7 +20,7 @@ import type {
   DeployableOptions,
   GenericDeployableParams,
 } from '../Deployable/Deployable';
-import { DeployableTarget } from '../Deployable/DeployableTarget';
+import { DeployableTargetWithRBAC } from '../Deployable/DeployableTargetWithRBAC';
 import { DeployableUnknownOwnerProvidedError } from '../errors';
 import {
   type GenericLog,
@@ -73,11 +74,14 @@ export type SimpleDenyListLog<
  * @export
  * @class SimpleDenyList
  * @typedef {SimpleDenyList}
- * @extends {DeployableTarget<SimpleDenyListPayload>}
+ * @extends {DeployableTargetWithRBAC<SimpleDenyListPayload>}
  */
 export class SimpleDenyList<
   Payload = SimpleDenyListPayload,
-> extends DeployableTarget<Payload | undefined, typeof simpleDenyListAbi> {
+> extends DeployableTargetWithRBAC<
+  Payload | undefined,
+  typeof simpleDenyListAbi
+> {
   public override readonly abi = simpleDenyListAbi;
   /**
    * @inheritdoc
@@ -98,6 +102,26 @@ export class SimpleDenyList<
    */
   public static override registryType: RegistryType = RegistryType.ALLOW_LIST;
 
+  /**
+   * Retrieves the owner
+   *
+   * @public
+   * @async
+   * @param {?ReadParams<typeof simpleDenyListAbi, 'owner'>} [params]
+   * @returns {Promise<Address>} - The address of the owner
+   */
+  public async owner(
+    params?: ReadParams<typeof simpleDenyListAbi, '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 (i.e. not denied)
    *

package/src/Budgets/Budget.ts

@@ -7,7 +7,6 @@ import { InvalidComponentInterfaceError } from '../errors';
 import { ManagedBudget } from './ManagedBudget';
 
 export {
-  // SimpleBudget,
   // VestingBudget,
   ManagedBudget,
 };
@@ -18,7 +17,7 @@ export {
  * @export
  * @typedef {Budget}
  */
-export type Budget = ManagedBudget; // | SimpleBudget | VestingBudget
+export type Budget = ManagedBudget; // | VestingBudget
 
 /**
  * A map of Budget component interfaces to their constructors.

package/src/Budgets/ManagedBudget.ts

@@ -39,6 +39,7 @@ import type {
   GenericDeployableParams,
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
+import { DeployableTargetWithRBAC } from '../Deployable/DeployableTargetWithRBAC';
 import {
   DeployableUnknownOwnerProvidedError,
   UnknownTransferPayloadSupplied,
@@ -170,9 +171,9 @@ export function prepareTransfer(
  * @export
  * @class ManagedBudget
  * @typedef {ManagedBudget}
- * @extends {DeployableTarget<ManagedBudgetPayload>}
+ * @extends {DeployableTargetWithRBAC<ManagedBudgetPayload>}
  */
-export class ManagedBudget extends DeployableTarget<
+export class ManagedBudget extends DeployableTargetWithRBAC<
   ManagedBudgetPayload,
   typeof managedBudgetAbi
 > {
@@ -387,281 +388,6 @@ export class ManagedBudget extends DeployableTarget<
     return { hash, result };
   }
 
-  /**
-   * Set the authorized status of the given accounts
-   * The mechanism for managing authorization is left to the implementing contract
-   *
-   * @public
-   * @async
-   * @param {Address[]} addresses - The accounts to authorize or deauthorize
-   * @param {boolean[]} allowed - The authorization status for the given accounts
-   * @param {?WriteParams<typeof managedBudgetAbi, 'setAuthorized'>} [params]
-   * @returns {Promise<void>}
-   */
-  public async setAuthorized(
-    addresses: Address[],
-    allowed: boolean[],
-    params?: WriteParams<typeof managedBudgetAbi, 'setAuthorized'>,
-  ) {
-    return await this.awaitResult(
-      this.setAuthorizedRaw(addresses, allowed, params),
-    );
-  }
-
-  /**
-   * Set the authorized status of the given accounts
-   * The mechanism for managing authorization is left to the implementing contract
-   *
-   * @public
-   * @async
-   * @param {Address[]} addresses - The accounts to authorize or deauthorize
-   * @param {boolean[]} allowed - The authorization status for the given accounts
-   * @param {?WriteParams<typeof managedBudgetAbi, 'setAuthorized'>} [params]
-   * @returns {Promise<void>}
-   */
-  public async setAuthorizedRaw(
-    addresses: Address[],
-    allowed: boolean[],
-    params?: WriteParams<typeof managedBudgetAbi, 'setAuthorized'>,
-  ) {
-    const { request, result } = await simulateManagedBudgetSetAuthorized(
-      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 writeManagedBudgetSetAuthorized(this._config, request);
-    return { hash, result };
-  }
-
-  /**
-   * Grant many accounts permissions on the budget.
-   *
-   * @example
-   * ```ts
-   * await budget.grantRoles(['0xfoo', '0xbar], [ManagedBudgetRoles.MANAGER, ManagedBudgetRoles.ADMIN])
-   * ```
-   * @public
-   * @async
-   * @param {Address[]} addresses
-   * @param {ManagedBudgetRoles[]} roles
-   * @param {?WriteParams<typeof managedBudgetAbi, 'grantRoles'>} [params]
-   * @returns {unknown}
-   */
-  public async grantRoles(
-    addresses: Address[],
-    roles: ManagedBudgetRoles[],
-    params?: WriteParams<typeof managedBudgetAbi, 'grantRoles'>,
-  ) {
-    return await this.awaitResult(this.grantRolesRaw(addresses, roles, params));
-  }
-
-  /**
-   * Grant many accounts permissions on the budget.
-   *
-   * @example
-   * ```ts
-   * await budget.grantRoles(['0xfoo', '0xbar], [ManagedBudgetRoles.MANAGER, ManagedBudgetRoles.ADMIN])
-   *
-   * @public
-   * @async
-   * @param {Address[]} addresses
-   * @param {ManagedBudgetRoles[]} roles
-   * @param {?WriteParams<typeof managedBudgetAbi, 'grantRoles'>} [params]
-   * @returns {unknown}
-   */
-  public async grantRolesRaw(
-    addresses: Address[],
-    roles: ManagedBudgetRoles[],
-    params?: WriteParams<typeof managedBudgetAbi, 'grantRoles'>,
-  ) {
-    const { request, result } = await simulateManagedBudgetGrantRoles(
-      this._config,
-      {
-        address: this.assertValidAddress(),
-        args: [addresses, roles],
-        ...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 writeManagedBudgetGrantRoles(
-      this._config,
-      // biome-ignore lint/suspicious/noExplicitAny: negligible low level lack of type intersection
-      request as any,
-    );
-    return { hash, result };
-  }
-
-  /**
-   * Revoke many accounts' permissions on the budget.
-   *
-   * @example
-   * ```ts
-   * await budget.revokeRoles(['0xfoo', '0xbar], [ManagedBudgetRoles.MANAGER, ManagedBudgetRoles.ADMIN])
-   *
-   * @public
-   * @async
-   * @param {Address[]} addresses
-   * @param {ManagedBudgetRoles[]} roles
-   * @param {?WriteParams<typeof managedBudgetAbi, 'revokeRoles'>} [params]
-   * @returns {unknown}
-   */
-  public async revokeRoles(
-    addresses: Address[],
-    roles: ManagedBudgetRoles[],
-    params?: WriteParams<typeof managedBudgetAbi, 'revokeRoles'>,
-  ) {
-    return await this.awaitResult(
-      this.revokeRolesRaw(addresses, roles, params),
-    );
-  }
-
-  /**
-   * Revoke many accounts' permissions on the budget.
-   *
-   * @example
-   * ```ts
-   * await budget.revokeRoles(['0xfoo', '0xbar], [ManagedBudgetRoles.MANAGER, ManagedBudgetRoles.ADMIN])
-   * @public
-   * @async
-   * @param {Address[]} addresses
-   * @param {ManagedBudgetRoles[]} roles
-   * @param {?WriteParams<typeof managedBudgetAbi, 'revokeRoles'>} [params]
-   * @returns {unknown}
-   */
-  public async revokeRolesRaw(
-    addresses: Address[],
-    roles: ManagedBudgetRoles[],
-    params?: WriteParams<typeof managedBudgetAbi, 'revokeRoles'>,
-  ) {
-    const { request, result } = await simulateManagedBudgetRevokeRoles(
-      this._config,
-      {
-        address: this.assertValidAddress(),
-        args: [addresses, roles],
-        ...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 writeManagedBudgetRevokeRoles(
-      this._config,
-      // biome-ignore lint/suspicious/noExplicitAny: negligible low level lack of type intersection
-      request as any,
-    );
-    return { hash, result };
-  }
-
-  /**
-   * Return an array of the roles assigned to the given account.
-   * @example
-   * ```ts
-   * (await budget.rolesOf(0xfoo)).includes(ManagedBudgetRoles.ADMIN)
-   * @public
-   * @param {Address} account
-   * @param {?ReadParams<typeof managedBudgetAbi, 'rolesOf'>} [params]
-   * @returns {Promise<Array<ManagedBudgetRoles>>}
-   */
-  public async rolesOf(
-    account: Address,
-    params?: ReadParams<typeof managedBudgetAbi, 'rolesOf'>,
-  ) {
-    const roles = await readManagedBudgetRolesOf(this._config, {
-      address: this.assertValidAddress(),
-      args: [account],
-      ...this.optionallyAttachAccount(),
-      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-      ...(params as any),
-    });
-    return (
-      [
-        ManagedBudgetRoles.MANAGER,
-        ManagedBudgetRoles.ADMIN,
-      ] as unknown as Array<bigint>
-    ).filter(
-      (role) => (roles & role) === role,
-    ) as unknown as ManagedBudgetRoles[];
-  }
-
-  /**
-   * Returns whether given account has any of the provided roles bitmap.
-   *
-   * @example
-   * ```ts
-   * await budget.hasAnyRole(0xfoo, ManagedBudgetRoles.ADMIN | ManagedBudgetRoles.MANAGER)
-   * @public
-   * @param {Address} account
-   * @param {ManagedBudgetRoles} roles
-   * @param {?ReadParams<typeof managedBudgetAbi, 'hasAnyRole'>} [params]
-   * @returns {Promise<boolean>}
-   */
-  public hasAnyRole(
-    account: Address,
-    roles: ManagedBudgetRoles,
-    params?: ReadParams<typeof managedBudgetAbi, 'hasAnyRole'>,
-  ) {
-    return readManagedBudgetHasAnyRole(this._config, {
-      address: this.assertValidAddress(),
-      args: [account, roles],
-      ...this.optionallyAttachAccount(),
-      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-      ...(params as any),
-    });
-  }
-
-  /**
-   * Returns whether given account has all of the provided roles bitmap.
-   *
-   * @example
-   * ```ts
-   * await budget.hasAllRoles(0xfoo, ManagedBudgetRoles.ADMIN & ManagedBudgetRoles.MANAGER)
-   *
-   * @public
-   * @param {Address} account
-   * @param {ManagedBudgetRoles} roles
-   * @param {?ReadParams<typeof managedBudgetAbi, 'hasAllRoles'>} [params]
-   * @returns {*}
-   */
-  public hasAllRoles(
-    account: Address,
-    roles: ManagedBudgetRoles,
-    params?: ReadParams<typeof managedBudgetAbi, 'hasAllRoles'>,
-  ) {
-    return readManagedBudgetHasAllRoles(this._config, {
-      address: this.assertValidAddress(),
-      args: [account, roles],
-      ...this.optionallyAttachAccount(),
-      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-      ...(params as any),
-    });
-  }
-
-  /**
-   * Check if the given account is authorized to use the budget
-   *
-   * @public
-   * @param {Address} account
-   * @param {?ReadParams<typeof managedBudgetAbi, 'isAuthorized'>} [params]
-   * @returns {Promise<boolean>} - True if the account is authorized
-   */
-  public isAuthorized(
-    account: Address,
-    params?: ReadParams<typeof managedBudgetAbi, 'isAuthorized'>,
-  ) {
-    return readManagedBudgetIsAuthorized(this._config, {
-      address: this.assertValidAddress(),
-      args: [account],
-      ...this.optionallyAttachAccount(),
-      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-      ...(params as any),
-    });
-  }
-
   /**
    * Get the owner of the budget
    *

package/src/Budgets/VestingBudget.ts

@@ -34,7 +34,7 @@ import type {
   DeployableOptions,
   GenericDeployableParams,
 } from '../Deployable/Deployable';
-import { DeployableTarget } from '../Deployable/DeployableTarget';
+import { DeployableTargetWithRBAC } from '../Deployable/DeployableTargetWithRBAC';
 import { DeployableUnknownOwnerProvidedError } from '../errors';
 import {
   type FungibleTransferPayload,
@@ -115,9 +115,9 @@ export type VestingBudgetLog<
  * @export
  * @class VestingBudget
  * @typedef {VestingBudget}
- * @extends {DeployableTarget<VestingBudgetPayload>}
+ * @extends {DeployableTargetWithRBAC<VestingBudgetPayload>}
  */
-export class VestingBudget extends DeployableTarget<
+export class VestingBudget extends DeployableTargetWithRBAC<
   VestingBudgetPayload,
   typeof vestingBudgetAbi
 > {
@@ -387,77 +387,6 @@ export class VestingBudget extends DeployableTarget<
     return { hash, result };
   }
 
-  /**
-   * Set the authorized status of the given accounts
-   * The mechanism for managing authorization is left to the implementing contract
-   *
-   * @public
-   * @async
-   * @param {Address[]} addresses - The accounts to authorize or deauthorize
-   * @param {boolean[]} allowed - The authorization status for the given accounts
-   * @param {?WriteParams<typeof vestingBudgetAbi, 'setAuthorized'>} [params]
-   * @returns {Promise<void>}
-   */
-  public async setAuthorized(
-    addresses: Address[],
-    allowed: boolean[],
-    params?: WriteParams<typeof vestingBudgetAbi, 'setAuthorized'>,
-  ) {
-    return await this.awaitResult(
-      this.setAuthorizedRaw(addresses, allowed, params),
-    );
-  }
-
-  /**
-   * Set the authorized status of the given accounts
-   * The mechanism for managing authorization is left to the implementing contract
-   *
-   * @public
-   * @async
-   * @param {Address[]} addresses - The accounts to authorize or deauthorize
-   * @param {boolean[]} allowed - The authorization status for the given accounts
-   * @param {?WriteParams<typeof vestingBudgetAbi, 'setAuthorized'>} [params]
-   * @returns {Promise<void>}
-   */
-  public async setAuthorizedRaw(
-    addresses: Address[],
-    allowed: boolean[],
-    params?: WriteParams<typeof vestingBudgetAbi, 'setAuthorized'>,
-  ) {
-    const { request, result } = await simulateVestingBudgetSetAuthorized(
-      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 writeVestingBudgetSetAuthorized(this._config, request);
-    return { hash, result };
-  }
-
-  /**
-   * Check if the given account is authorized to use the budget
-   *
-   * @public
-   * @param {Address} account
-   * @param {?ReadParams<typeof vestingBudgetAbi, 'isAuthorized'>} [params]
-   * @returns {Promise<boolean>} - True if the account is authorized
-   */
-  public isAuthorized(
-    account: Address,
-    params?: ReadParams<typeof vestingBudgetAbi, 'isAuthorized'>,
-  ) {
-    return readVestingBudgetIsAuthorized(this._config, {
-      address: this.assertValidAddress(),
-      args: [account],
-      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-      ...(params as any),
-    });
-  }
-
   /**
    * Get the end time of the vesting schedule
    *