@boostxyz/sdk 0.0.0-alpha.16 → 0.0.0-alpha.18

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,
@@ -148,7 +149,7 @@ export function isERC1155TransferPayload(
  *
  * @export
  * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
- * @returns {*}
+ * @returns {Hex}
  * @throws {@link UnknownTransferPayloadSupplied}
  */
 export function prepareTransfer(
@@ -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
 > {
@@ -211,7 +212,7 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
-   * @param {?WriteParams<typeof managedBudgetAbi, 'allocate'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} - True if the allocation was successful
    */
   public async allocate(
@@ -229,8 +230,8 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
-   * @param {?WriteParams<typeof managedBudgetAbi, 'allocate'>} [params]
-   * @returns {Promise<boolean>} - True if the allocation was successful
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the allocation was successful
    */
   public async allocateRaw(
     transfer: FungibleTransferPayload | ERC1155TransferPayload,
@@ -259,7 +260,7 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
-   * @param {?WriteParams<typeof managedBudgetAbi, 'clawback'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} - True if the request was successful
    */
   public async clawback(
@@ -278,8 +279,8 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
-   * @param {?WriteParams<typeof managedBudgetAbi, 'clawback'>} [params]
-   * @returns {Promise<boolean>} - True if the request was successful
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the request was successful
    */
   public async clawbackRaw(
     transfer: FungibleTransferPayload | ERC1155TransferPayload,
@@ -306,7 +307,7 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
-   * @param {?WriteParams<typeof managedBudgetAbi, 'disburse'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} - True if the disbursement was successful
    */
   public async disburse(
@@ -323,8 +324,8 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
-   * @param {?WriteParams<typeof managedBudgetAbi, 'disburse'>} [params]
-   * @returns {Promise<boolean>} - True if the disbursement was successful
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the disbursement was successful
    */
   public async disburseRaw(
     transfer: FungibleTransferPayload | ERC1155TransferPayload,
@@ -350,7 +351,7 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {Array<FungibleTransferPayload | ERC1155TransferPayload>} transfers
-   * @param {?WriteParams<typeof managedBudgetAbi, 'disburseBatch'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} - True if all disbursements were successful
    */
   public async disburseBatch(
@@ -366,8 +367,8 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @async
    * @param {Array<FungibleTransferPayload | ERC1155TransferPayload>} transfers
-   * @param {?WriteParams<typeof managedBudgetAbi, 'disburseBatch'>} [params]
-   * @returns {Promise<boolean>} - True if all disbursements were successful
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if all disbursements were successful
    */
   public async disburseBatchRaw(
     transfers: Array<FungibleTransferPayload | ERC1155TransferPayload>,
@@ -387,286 +388,11 @@ 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
    *
    * @public
-   * @param {?ReadParams<typeof managedBudgetAbi, 'owner'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Address>}
    */
   public owner(params?: ReadParams<typeof managedBudgetAbi, 'owner'>) {
@@ -685,7 +411,7 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @param {Address} [asset="0x0000000000000000000000000000000000000000"] - The address of the asset
    * @param {?(bigint | undefined)} [tokenId] - The ID of the token
-   * @param {?ReadParams<typeof managedBudgetAbi, 'total'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>} - The total amount of assets
    */
   public total(
@@ -708,7 +434,7 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @param {Address} [asset="0x0000000000000000000000000000000000000000"]
    * @param {?(bigint | undefined)} [tokenId]
-   * @param {?ReadParams<typeof managedBudgetAbi, 'available'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>} - The amount of assets available
    */
   public available(
@@ -731,7 +457,7 @@ export class ManagedBudget extends DeployableTarget<
    * @public
    * @param {Address} [asset="0x0000000000000000000000000000000000000000"]
    * @param {?(bigint | undefined)} [tokenId]
-   * @param {?ReadParams<typeof managedBudgetAbi, 'distributed'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>} - The amount of assets distributed
    */
   public distributed(
@@ -791,7 +517,7 @@ export class ManagedBudget extends DeployableTarget<
  * @param {Address} param0.owner - The budget's owner
  * @param {{}} param0.authorized - List of accounts authorized to use the budget. This list should include a Boost core address to interact with the protocol.
  * @param {{}} param0.roles - List of roles to assign to the corresponding account by index.
- * @returns {*}
+ * @returns {Hex}
  */
 export const prepareManagedBudgetPayload = ({
   owner,

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
 > {
@@ -143,7 +143,7 @@ export class VestingBudget extends DeployableTarget<
    * Get the owner of the budget
    *
    * @public
-   * @param {?ReadParams<typeof vestingBudgetAbi, 'owner'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<Address>}
    */
   public owner(params?: ReadParams<typeof vestingBudgetAbi, 'owner'>) {
@@ -159,8 +159,8 @@ export class VestingBudget extends DeployableTarget<
    * The timestamp at which the vesting schedule begins
    *
    * @public
-   * @param {?ReadParams<typeof vestingBudgetAbi, 'start'>} [params]
-   * @returns {*}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>}
    */
   public start(params?: ReadParams<typeof vestingBudgetAbi, 'start'>) {
     return readVestingBudgetStart(this._config, {
@@ -175,8 +175,8 @@ export class VestingBudget extends DeployableTarget<
    * The duration of the vesting schedule (in seconds)
    *
    * @public
-   * @param {?ReadParams<typeof vestingBudgetAbi, 'duration'>} [params]
-   * @returns {*}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>}
    */
   public duration(params?: ReadParams<typeof vestingBudgetAbi, 'duration'>) {
     return readVestingBudgetDuration(this._config, {
@@ -191,8 +191,8 @@ export class VestingBudget extends DeployableTarget<
    * The duration of the cliff period (in seconds)
    *
    * @public
-   * @param {?ReadParams<typeof vestingBudgetAbi, 'cliff'>} [params]
-   * @returns {*}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<bigint>}
    */
   public cliff(params?: ReadParams<typeof vestingBudgetAbi, 'cliff'>) {
     return readVestingBudgetCliff(this._config, {
@@ -211,7 +211,7 @@ export class VestingBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload)} transfer
-   * @param {?WriteParams<typeof vestingBudgetAbi, 'allocate'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} - True if the allocation was successful
    */
   public async allocate(
@@ -229,8 +229,8 @@ export class VestingBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload)} transfer
-   * @param {?WriteParams<typeof vestingBudgetAbi, 'allocate'>} [params]
-   * @returns {Promise<boolean>} - True if the allocation was successful
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the allocation was successful
    */
   public async allocateRaw(
     transfer: FungibleTransferPayload,
@@ -259,7 +259,7 @@ export class VestingBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload)} transfer
-   * @param {?WriteParams<typeof vestingBudgetAbi, 'clawback'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} - True if the request was successful
    */
   public async clawback(
@@ -278,8 +278,8 @@ export class VestingBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload)} transfer
-   * @param {?WriteParams<typeof vestingBudgetAbi, 'clawback'>} [params]
-   * @returns {Promise<boolean>} - True if the request was successful
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the request was successful
    */
   public async clawbackRaw(
     transfer: FungibleTransferPayload,
@@ -306,7 +306,7 @@ export class VestingBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload)} transfer
-   * @param {?WriteParams<typeof vestingBudgetAbi, 'disburse'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} - True if the disbursement was successful
    */
   public async disburse(
@@ -323,8 +323,8 @@ export class VestingBudget extends DeployableTarget<
    * @public
    * @async
    * @param {(FungibleTransferPayload)} transfer
-   * @param {?WriteParams<typeof vestingBudgetAbi, 'disburse'>} [params]
-   * @returns {Promise<boolean>} - True if the disbursement was successful
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the disbursement was successful
    */
   public async disburseRaw(
     transfer: FungibleTransferPayload,
@@ -350,7 +350,7 @@ export class VestingBudget extends DeployableTarget<
    * @public
    * @async
    * @param {Array<FungibleTransferPayload>} transfers
-   * @param {?WriteParams<typeof vestingBudgetAbi, 'disburseBatch'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<boolean>} - True if all disbursements were successful
    */
   public async disburseBatch(
@@ -366,8 +366,8 @@ export class VestingBudget extends DeployableTarget<
    * @public
    * @async
    * @param {Array<FungibleTransferPayload>} transfers
-   * @param {?WriteParams<typeof vestingBudgetAbi, 'disburseBatch'>} [params]
-   * @returns {Promise<boolean>} - True if all disbursements were successful
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if all disbursements were successful
    */
   public async disburseBatchRaw(
     transfers: FungibleTransferPayload[],
@@ -387,82 +387,11 @@ 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
    *
    * @public
-   * @param {?ReadParams<typeof vestingBudgetAbi, 'end'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public end(params?: ReadParams<typeof vestingBudgetAbi, 'end'>) {
@@ -480,7 +409,7 @@ export class VestingBudget extends DeployableTarget<
    *
    * @public
    * @param {Address} [asset="0x0000000000000000000000000000000000000000"] -  The address of the asset (or the zero address for native assets)
-   * @param {?ReadParams<typeof vestingBudgetAbi, 'total'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public total(
@@ -501,7 +430,7 @@ export class VestingBudget extends DeployableTarget<
    *
    * @public
    * @param {Address} [asset="0x0000000000000000000000000000000000000000"] -  The address of the asset (or the zero address for native assets)
-   * @param {?ReadParams<typeof vestingBudgetAbi, 'available'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>} - The amount of assets currently available for distribution
    */
   public available(
@@ -521,7 +450,7 @@ export class VestingBudget extends DeployableTarget<
    *
    * @public
    * @param {Address} [asset="0x0000000000000000000000000000000000000000"]
-   * @param {?ReadParams<typeof vestingBudgetAbi, 'distributed'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>} - The amount of assets distributed
    */
   public distributed(