@boostxyz/sdk 0.0.0-alpha.10

package/src/Budgets/SimpleBudget.test.ts

@@ -0,0 +1,152 @@
+import { writeMockErc1155SetApprovalForAll } from '@boostxyz/evm';
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { isAddress, parseEther, zeroAddress } from 'viem';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import type { MockERC20 } from '../../test/MockERC20';
+import type { MockERC1155 } from '../../test/MockERC1155';
+import {
+  type Fixtures,
+  defaultOptions,
+  deployFixtures,
+  freshBudget,
+  fundBudget,
+  fundErc20,
+  fundErc1155,
+} from '../../test/helpers';
+import { testAccount } from '../../test/viem';
+import { SimpleBudget } from './SimpleBudget';
+
+let fixtures: Fixtures,
+  budget: SimpleBudget,
+  erc20: MockERC20,
+  erc1155: MockERC1155;
+
+beforeAll(async () => {
+  fixtures = await loadFixture(deployFixtures);
+});
+
+describe.skip('SimpleBudget', () => {
+  test('can successfully be deployed', async () => {
+    const action = new SimpleBudget(defaultOptions, {
+      owner: testAccount.address,
+      authorized: [],
+    });
+    await action.deploy();
+    expect(isAddress(action.assertValidAddress())).toBe(true);
+  });
+
+  test('can be owned', async () => {
+    const budget = await loadFixture(freshBudget(defaultOptions, fixtures));
+    expect(await budget.owner()).toBe(defaultOptions.account.address);
+  });
+
+  test('can have authorized users', async () => {
+    const budget = await loadFixture(freshBudget(defaultOptions, fixtures));
+    expect(await budget.isAuthorized(defaultOptions.account.address)).toBe(
+      true,
+    );
+    expect(await budget.isAuthorized(zeroAddress)).toBe(false);
+  });
+
+  test('can have no initial balance', async () => {
+    const budget = await loadFixture(freshBudget(defaultOptions, fixtures));
+    expect(await budget.available(zeroAddress)).toBe(0n);
+  });
+
+  describe('can allocate', () => {
+    beforeEach(async () => {
+      budget = await loadFixture(freshBudget(defaultOptions, fixtures));
+      erc20 = await loadFixture(fundErc20(defaultOptions));
+      erc1155 = await loadFixture(fundErc1155(defaultOptions));
+    });
+
+    test('native assets', async () => {
+      await budget.allocate(
+        {
+          amount: parseEther('1.0'),
+          asset: zeroAddress,
+          target: defaultOptions.account.address,
+        },
+        {
+          value: parseEther('1.0'),
+        },
+      );
+      expect(await budget.available(zeroAddress)).toBe(parseEther('1.0'));
+    });
+
+    test('erc20', async () => {
+      await erc20.approve(budget.assertValidAddress(), parseEther('100'));
+      await budget.allocate({
+        amount: parseEther('100'),
+        asset: erc20.assertValidAddress(),
+        target: defaultOptions.account.address,
+      });
+      expect(await budget.available(erc20.assertValidAddress())).toBe(
+        parseEther('100'),
+      );
+    });
+
+    test('erc1155', async () => {
+      await writeMockErc1155SetApprovalForAll(defaultOptions.config, {
+        args: [budget.assertValidAddress(), true],
+        address: erc1155.assertValidAddress(),
+        account: defaultOptions.account,
+      });
+      await budget.allocate({
+        tokenId: 1n,
+        amount: 100n,
+        asset: erc1155.assertValidAddress(),
+        target: defaultOptions.account.address,
+      });
+      expect(await budget.available(erc1155.assertValidAddress(), 1n)).toBe(
+        100n,
+      );
+    });
+  });
+
+  describe('can disburse', () => {
+    beforeEach(async () => {
+      const budgetFixtures = await loadFixture(
+        fundBudget(defaultOptions, fixtures),
+      );
+      budget = budgetFixtures.budget;
+      erc20 = budgetFixtures.erc20;
+      erc1155 = budgetFixtures.erc1155;
+    });
+
+    test('native assets', async () => {
+      await budget.disburse({
+        amount: parseEther('1.0'),
+        asset: zeroAddress,
+        target: defaultOptions.account.address,
+      });
+
+      expect(await budget.available(zeroAddress)).toBe(0n);
+    });
+
+    test('erc20 assets', async () => {
+      await budget.disburse({
+        amount: parseEther('10'),
+        asset: erc20.assertValidAddress(),
+        target: defaultOptions.account.address,
+      });
+
+      expect(await budget.available(erc20.assertValidAddress())).toBe(
+        parseEther('90'),
+      );
+    });
+
+    test('erc1155 assets', async () => {
+      await budget.disburse({
+        tokenId: 1n,
+        amount: 5n,
+        asset: erc1155.assertValidAddress(),
+        target: defaultOptions.account.address,
+      });
+
+      expect(await budget.available(erc1155.assertValidAddress(), 1n)).to.equal(
+        95n,
+      );
+    });
+  });
+});

package/src/Budgets/SimpleBudget.ts

@@ -0,0 +1,564 @@
+import {
+  readSimpleBudgetAvailable,
+  readSimpleBudgetDistributed,
+  readSimpleBudgetIsAuthorized,
+  readSimpleBudgetOwner,
+  readSimpleBudgetTotal,
+  simpleBudgetAbi,
+  simulateSimpleBudgetAllocate,
+  simulateSimpleBudgetClawback,
+  simulateSimpleBudgetDisburse,
+  simulateSimpleBudgetDisburseBatch,
+  simulateSimpleBudgetSetAuthorized,
+  writeSimpleBudgetAllocate,
+  writeSimpleBudgetClawback,
+  writeSimpleBudgetDisburse,
+  writeSimpleBudgetDisburseBatch,
+  writeSimpleBudgetSetAuthorized,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/budgets/SimpleBudget.sol/SimpleBudget.json';
+import { getAccount } from '@wagmi/core';
+import {
+  type Address,
+  type ContractEventName,
+  type Hex,
+  encodeAbiParameters,
+  parseAbiParameters,
+  zeroAddress,
+} from 'viem';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import {
+  DeployableUnknownOwnerProvidedError,
+  UnknownTransferPayloadSupplied,
+} from '../errors';
+import {
+  type ERC1155TransferPayload,
+  type FungibleTransferPayload,
+  prepareERC1155Transfer,
+  prepareFungibleTransfer,
+} from '../transfers';
+import {
+  type GenericLog,
+  type ReadParams,
+  RegistryType,
+  type WriteParams,
+} from '../utils';
+
+export { simpleBudgetAbi };
+export type { ERC1155TransferPayload, FungibleTransferPayload };
+
+/**
+ * The object representation of a `SimpleBudgetPayload.InitPayload`
+ *
+ * @export
+ * @interface SimpleBudgetPayload
+ * @typedef {SimpleBudgetPayload}
+ */
+export interface SimpleBudgetPayload {
+  /**
+   * The budget's owner
+   *
+   * @type {Address}
+   */
+  owner: Address;
+  /**
+   * List of accounts authorized to use the budget. This list should include a Boost core address to interact with the protocol.
+   *
+   * @type {Address[]}
+   */
+  authorized: Address[];
+}
+
+/**
+ * A generic `viem.Log` event with support for `SimpleBudget` event types.
+ *
+ * @export
+ * @typedef {SimpleBudgetLog}
+ * @template {ContractEventName<typeof simpleBudgetAbi>} [event=ContractEventName<
+ *     typeof simpleBudgetAbi
+ *   >]
+ */
+export type SimpleBudgetLog<
+  event extends ContractEventName<typeof simpleBudgetAbi> = ContractEventName<
+    typeof simpleBudgetAbi
+  >,
+> = GenericLog<typeof simpleBudgetAbi, event>;
+
+/**
+ * Typeguard to determine if a transfer payload is a Fungible Transfer
+ *
+ * @export
+ * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
+ * @returns {transfer is FungibleTransferPayload}
+ */
+export function isFungibleTransfer(
+  transfer: FungibleTransferPayload | ERC1155TransferPayload,
+): transfer is FungibleTransferPayload {
+  return (transfer as ERC1155TransferPayload).tokenId === undefined;
+}
+
+/**
+ * Typeguard to determine if a transfer payload is an ERC1155 Transfer
+ *
+ * @export
+ * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
+ * @returns {transfer is ERC1155TransferPayload}
+ */
+export function isERC1155TransferPayload(
+  transfer: FungibleTransferPayload | ERC1155TransferPayload,
+): transfer is ERC1155TransferPayload {
+  return (transfer as ERC1155TransferPayload).tokenId !== undefined;
+}
+
+/**
+ * Given either a Fungible transfer, or ERC1155 transfer, will properly encode parameters for transfers, claims, disbursements, allocations, etc.
+ *
+ * @export
+ * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
+ * @returns {*}
+ * @throws {@link UnknownTransferPayloadSupplied}
+ */
+export function prepareTransfer(
+  transfer: FungibleTransferPayload | ERC1155TransferPayload,
+) {
+  if (isFungibleTransfer(transfer)) {
+    return prepareFungibleTransfer(transfer);
+  } else if (isERC1155TransferPayload(transfer)) {
+    return prepareERC1155Transfer(transfer);
+  } else throw new UnknownTransferPayloadSupplied(transfer);
+}
+
+/**
+ * A minimal budget implementation that simply holds and distributes tokens (ERC20-like and native)
+ * This type of budget supports ETH, ERC20, and ERC1155 assets only
+ *
+ * @export
+ * @class SimpleBudget
+ * @typedef {SimpleBudget}
+ * @extends {DeployableTarget<SimpleBudgetPayload>}
+ */
+export class SimpleBudget extends DeployableTarget<
+  SimpleBudgetPayload,
+  typeof simpleBudgetAbi
+> {
+  public override readonly abi = simpleBudgetAbi;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Address}
+   */
+  public static override base: Address = import.meta.env
+    .VITE_SIMPLE_BUDGET_BASE;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.BUDGET;
+
+  /**
+   *  Allocates assets to the budget.
+   *  The caller must have already approved the contract to transfer the asset
+   *  If the asset transfer fails, the allocation will revert
+   *
+   * @public
+   * @async
+   * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
+   * @param {?WriteParams<typeof simpleBudgetAbi, 'allocate'>} [params]
+   * @returns {Promise<boolean>} - True if the allocation was successful
+   */
+  public async allocate(
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'allocate'>,
+  ) {
+    return await this.awaitResult(this.allocateRaw(transfer, params));
+  }
+
+  /**
+   *  Allocates assets to the budget.
+   *  The caller must have already approved the contract to transfer the asset
+   *  If the asset transfer fails, the allocation will revert
+   *
+   * @public
+   * @async
+   * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
+   * @param {?WriteParams<typeof simpleBudgetAbi, 'allocate'>} [params]
+   * @returns {Promise<boolean>} - True if the allocation was successful
+   */
+  public async allocateRaw(
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'allocate'>,
+  ) {
+    const { request, result } = await simulateSimpleBudgetAllocate(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [prepareTransfer(transfer)],
+        ...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 writeSimpleBudgetAllocate(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * Clawbacks assets from the budget.
+   * Only the owner can directly clawback assets from the budget
+   * If the amount is zero, the entire balance of the asset will be transferred to the receiver
+   * If the asset transfer fails, the reclamation will revert
+   *
+   * @public
+   * @async
+   * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
+   * @param {?WriteParams<typeof simpleBudgetAbi, 'clawback'>} [params]
+   * @returns {Promise<boolean>} - True if the request was successful
+   */
+  public async clawback(
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'clawback'>,
+  ) {
+    return await this.awaitResult(this.clawbackRaw(transfer, params));
+  }
+
+  /**
+   * Clawbacks assets from the budget.
+   * Only the owner can directly clawback assets from the budget
+   * If the amount is zero, the entire balance of the asset will be transferred to the receiver
+   * If the asset transfer fails, the reclamation will revert
+   *
+   * @public
+   * @async
+   * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
+   * @param {?WriteParams<typeof simpleBudgetAbi, 'clawback'>} [params]
+   * @returns {Promise<boolean>} - True if the request was successful
+   */
+  public async clawbackRaw(
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'clawback'>,
+  ) {
+    const { request, result } = await simulateSimpleBudgetClawback(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [prepareTransfer(transfer)],
+        ...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 writeSimpleBudgetClawback(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * Disburses assets from the budget to a single recipient
+   * If the asset transfer fails, the disbursement will revert
+   *
+   * @public
+   * @async
+   * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
+   * @param {?WriteParams<typeof simpleBudgetAbi, 'disburse'>} [params]
+   * @returns {Promise<boolean>} - True if the disbursement was successful
+   */
+  public async disburse(
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'disburse'>,
+  ) {
+    return await this.awaitResult(this.disburseRaw(transfer, params));
+  }
+
+  /**
+   * Disburses assets from the budget to a single recipient
+   * If the asset transfer fails, the disbursement will revert
+   *
+   * @public
+   * @async
+   * @param {(FungibleTransferPayload | ERC1155TransferPayload)} transfer
+   * @param {?WriteParams<typeof simpleBudgetAbi, 'disburse'>} [params]
+   * @returns {Promise<boolean>} - True if the disbursement was successful
+   */
+  public async disburseRaw(
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'disburse'>,
+  ) {
+    const { request, result } = await simulateSimpleBudgetDisburse(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [prepareTransfer(transfer)],
+        ...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 writeSimpleBudgetDisburse(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * Disburses assets from the budget to multiple recipients
+   *
+   * @public
+   * @async
+   * @param {Array<FungibleTransferPayload | ERC1155TransferPayload>} transfers
+   * @param {?WriteParams<typeof simpleBudgetAbi, 'disburseBatch'>} [params]
+   * @returns {Promise<boolean>} - True if all disbursements were successful
+   */
+  public async disburseBatch(
+    transfers: Array<FungibleTransferPayload | ERC1155TransferPayload>,
+    params?: WriteParams<typeof simpleBudgetAbi, 'disburseBatch'>,
+  ) {
+    return await this.awaitResult(this.disburseBatchRaw(transfers, params));
+  }
+
+  /**
+   * Disburses assets from the budget to multiple recipients
+   *
+   * @public
+   * @async
+   * @param {Array<FungibleTransferPayload | ERC1155TransferPayload>} transfers
+   * @param {?WriteParams<typeof simpleBudgetAbi, 'disburseBatch'>} [params]
+   * @returns {Promise<boolean>} - True if all disbursements were successful
+   */
+  public async disburseBatchRaw(
+    transfers: Array<FungibleTransferPayload | ERC1155TransferPayload>,
+    params?: WriteParams<typeof simpleBudgetAbi, 'disburseBatch'>,
+  ) {
+    const { request, result } = await simulateSimpleBudgetDisburseBatch(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [transfers.map(prepareTransfer)],
+        ...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 writeSimpleBudgetDisburseBatch(this._config, request);
+    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 simpleBudgetAbi, 'setAuthorized'>} [params]
+   * @returns {Promise<void>}
+   */
+  public async setAuthorized(
+    addresses: Address[],
+    allowed: boolean[],
+    params?: WriteParams<typeof simpleBudgetAbi, '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 simpleBudgetAbi, 'setAuthorized'>} [params]
+   * @returns {Promise<void>}
+   */
+  public async setAuthorizedRaw(
+    addresses: Address[],
+    allowed: boolean[],
+    params?: WriteParams<typeof simpleBudgetAbi, 'setAuthorized'>,
+  ) {
+    const { request, result } = await simulateSimpleBudgetSetAuthorized(
+      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 writeSimpleBudgetSetAuthorized(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * Check if the given account is authorized to use the budget
+   *
+   * @public
+   * @param {Address} account
+   * @param {?ReadParams<typeof simpleBudgetAbi, 'isAuthorized'>} [params]
+   * @returns {Promise<boolean>} - True if the account is authorized
+   */
+  public isAuthorized(
+    account: Address,
+    params?: ReadParams<typeof simpleBudgetAbi, 'isAuthorized'>,
+  ) {
+    return readSimpleBudgetIsAuthorized(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 simpleBudgetAbi, 'owner'>} [params]
+   * @returns {Promise<Address>}
+   */
+  public owner(params?: ReadParams<typeof simpleBudgetAbi, 'owner'>) {
+    return readSimpleBudgetOwner(this._config, {
+      address: this.assertValidAddress(),
+      args: [],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Get the total amount of assets allocated to the budget, including any that have been distributed
+   * If a tokenId is provided, get the total amount of ERC1155 assets allocated to the budget, including any that have been distributed
+   *
+   * @public
+   * @param {Address} asset - The address of the asset
+   * @param {?(bigint | undefined)} [tokenId] - The ID of the token
+   * @param {?ReadParams<typeof simpleBudgetAbi, 'total'>} [params]
+   * @returns {Promise<bigint>} - The total amount of assets
+   */
+  public total(
+    asset: Address,
+    tokenId?: bigint | undefined,
+    params?: ReadParams<typeof simpleBudgetAbi, 'total'>,
+  ) {
+    return readSimpleBudgetTotal(this._config, {
+      address: this.assertValidAddress(),
+      args: tokenId ? [asset, tokenId] : [asset],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Get the amount of assets available for distribution from the budget.
+   * If a tokenId is provided, get the amount of ERC1155 assets available for distribution from the budget
+   *
+   * @public
+   * @param {Address} asset
+   * @param {?(bigint | undefined)} [tokenId]
+   * @param {?ReadParams<typeof simpleBudgetAbi, 'available'>} [params]
+   * @returns {Promise<bigint>} - The amount of assets available
+   */
+  public available(
+    asset: Address,
+    tokenId?: bigint | undefined,
+    params?: ReadParams<typeof simpleBudgetAbi, 'available'>,
+  ) {
+    return readSimpleBudgetAvailable(this._config, {
+      address: this.assertValidAddress(),
+      args: tokenId ? [asset, tokenId] : [asset],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Get the amount of assets that have been distributed from the budget.
+   * If a tokenId is provided, get the amount of ERC1155 assets that have been distributed from the budget
+   *
+   * @public
+   * @param {Address} asset
+   * @param {?(bigint | undefined)} [tokenId]
+   * @param {?ReadParams<typeof simpleBudgetAbi, 'distributed'>} [params]
+   * @returns {Promise<bigint>} - The amount of assets distributed
+   */
+  public distributed(
+    asset: Address,
+    tokenId?: bigint | undefined,
+    params?: ReadParams<typeof simpleBudgetAbi, 'distributed'>,
+  ) {
+    return readSimpleBudgetDistributed(this._config, {
+      address: this.assertValidAddress(),
+      args: tokenId ? [asset, tokenId] : [asset],
+      // 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 {?SimpleBudgetPayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: SimpleBudgetPayload,
+    _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: simpleBudgetAbi,
+      bytecode: bytecode as Hex,
+      args: [prepareSimpleBudgetPayload(payload)],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}
+
+/**
+ * Given a {@link SimpleBudgetPayload}, properly encode a `SimpleBudget.InitPayload` for use with {@link SimpleBudget} initialization.
+ *
+ * @param {SimpleBudgetPayload} param0
+ * @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.
+ * @returns {*}
+ */
+export const prepareSimpleBudgetPayload = ({
+  owner,
+  authorized,
+}: SimpleBudgetPayload) => {
+  return encodeAbiParameters(
+    parseAbiParameters([
+      'SimpleBudgetPayload payload',
+      'struct SimpleBudgetPayload { address owner; address[] authorized; }',
+    ]),
+    [{ owner, authorized }],
+  );
+};