@boostxyz/sdk 0.0.0-alpha.10

package/dist/Budgets/VestingBudget.d.ts

@@ -0,0 +1,778 @@
+import { vestingBudgetAbi } from '@boostxyz/evm';
+import { type Address, type ContractEventName } from 'viem';
+import type { DeployableOptions, GenericDeployableParams } from '../Deployable/Deployable';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import { type FungibleTransferPayload } from '../transfers';
+import { type GenericLog, type ReadParams, RegistryType, type WriteParams } from '../utils';
+export { vestingBudgetAbi };
+export type { FungibleTransferPayload };
+/**
+ * The object representation of a `VestingBudget.InitPayload`
+ *
+ * @export
+ * @interface VestingBudgetPayload
+ * @typedef {VestingBudgetPayload}
+ */
+export interface VestingBudgetPayload {
+    /**
+     * 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[];
+    /**
+     * The timestamp at which the vesting schedule begins
+     *
+     * @type {bigint}
+     */
+    start: bigint;
+    /**
+     * The duration of the vesting schedule (in seconds)
+     *
+     * @type {bigint}
+     */
+    duration: bigint;
+    /**
+     * The duration of the cliff period (in seconds)
+     *
+     * @type {bigint}
+     */
+    cliff: bigint;
+}
+/**
+ * A generic `viem.Log` event with support for `VestingBudget` event types.
+ *
+ * @export
+ * @typedef {VestingBudgetLog}
+ * @template {ContractEventName<typeof vestingBudgetAbi>} [event=ContractEventName<
+ *     typeof vestingBudgetAbi
+ *   >]
+ */
+export type VestingBudgetLog<event extends ContractEventName<typeof vestingBudgetAbi> = ContractEventName<typeof vestingBudgetAbi>> = GenericLog<typeof vestingBudgetAbi, event>;
+/**
+ * A vesting-based budget implementation that allows for the distribution of assets over time
+ * Take note of the following when making use of this budget type:
+ * - The budget is designed to manage native and ERC20 token balances only. Using rebasing tokens or other non-standard token types may result in unexpected behavior.
+ * - Any assets allocated to this type of budget will follow the vesting schedule as if they were locked from the beginning, which is to say that, if the vesting has already started, some portion of the assets will be immediately available for distribution.
+ * - A vesting budget can also act as a time-lock, unlocking all assets at a specified point in time. To release assets at a specific time rather than vesting them over time, set the `start` to the desired time and the `duration` to zero.
+ * - This contract is {Ownable} to enable the owner to allocate to the budget, clawback and disburse assets from the budget, and to set authorized addresses. Additionally, the owner can transfer ownership of the budget to another address. Doing so has no effect on the vesting schedule.
+ *
+ * @export
+ * @class VestingBudget
+ * @typedef {VestingBudget}
+ * @extends {DeployableTarget<VestingBudgetPayload>}
+ */
+export declare class VestingBudget extends DeployableTarget<VestingBudgetPayload, typeof vestingBudgetAbi> {
+    readonly abi: readonly [{
+        readonly type: "constructor";
+        readonly inputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "AlreadyInitialized";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "CloneAlreadyInitialized";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "InitializerNotImplemented";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [{
+            readonly name: "asset";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "available";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "required";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+        readonly name: "InsufficientFunds";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [{
+            readonly name: "asset";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+        readonly name: "InvalidAllocation";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "InvalidInitialization";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "InvalidInitializationData";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "LengthMismatch";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "NewOwnerIsZeroAddress";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "NoHandoverRequest";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "NotImplemented";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "NotInitializing";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "Reentrancy";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [{
+            readonly name: "asset";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "to";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+        readonly name: "TransferFailed";
+    }, {
+        readonly type: "error";
+        readonly inputs: readonly [];
+        readonly name: "Unauthorized";
+    }, {
+        readonly type: "event";
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly name: "account";
+            readonly internalType: "address";
+            readonly type: "address";
+            readonly indexed: true;
+        }, {
+            readonly name: "isAuthorized";
+            readonly internalType: "bool";
+            readonly type: "bool";
+            readonly indexed: false;
+        }];
+        readonly name: "Authorized";
+    }, {
+        readonly type: "event";
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly name: "asset";
+            readonly internalType: "address";
+            readonly type: "address";
+            readonly indexed: true;
+        }, {
+            readonly name: "to";
+            readonly internalType: "address";
+            readonly type: "address";
+            readonly indexed: false;
+        }, {
+            readonly name: "amount";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+            readonly indexed: false;
+        }];
+        readonly name: "Distributed";
+    }, {
+        readonly type: "event";
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly name: "version";
+            readonly internalType: "uint64";
+            readonly type: "uint64";
+            readonly indexed: false;
+        }];
+        readonly name: "Initialized";
+    }, {
+        readonly type: "event";
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly name: "pendingOwner";
+            readonly internalType: "address";
+            readonly type: "address";
+            readonly indexed: true;
+        }];
+        readonly name: "OwnershipHandoverCanceled";
+    }, {
+        readonly type: "event";
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly name: "pendingOwner";
+            readonly internalType: "address";
+            readonly type: "address";
+            readonly indexed: true;
+        }];
+        readonly name: "OwnershipHandoverRequested";
+    }, {
+        readonly type: "event";
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly name: "oldOwner";
+            readonly internalType: "address";
+            readonly type: "address";
+            readonly indexed: true;
+        }, {
+            readonly name: "newOwner";
+            readonly internalType: "address";
+            readonly type: "address";
+            readonly indexed: true;
+        }];
+        readonly name: "OwnershipTransferred";
+    }, {
+        readonly type: "fallback";
+        readonly stateMutability: "payable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "data_";
+            readonly internalType: "bytes";
+            readonly type: "bytes";
+        }];
+        readonly name: "allocate";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "bool";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "payable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "asset_";
+            readonly internalType: "address";
+            readonly type: "address";
+        }];
+        readonly name: "available";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [];
+        readonly name: "cancelOwnershipHandover";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "data_";
+            readonly internalType: "bytes";
+            readonly type: "bytes";
+        }];
+        readonly name: "clawback";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "bool";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [];
+        readonly name: "cliff";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "uint64";
+            readonly type: "uint64";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "pendingOwner";
+            readonly internalType: "address";
+            readonly type: "address";
+        }];
+        readonly name: "completeOwnershipHandover";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "data_";
+            readonly internalType: "bytes";
+            readonly type: "bytes";
+        }];
+        readonly name: "disburse";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "bool";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "data_";
+            readonly internalType: "bytes[]";
+            readonly type: "bytes[]";
+        }];
+        readonly name: "disburseBatch";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "bool";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "asset_";
+            readonly internalType: "address";
+            readonly type: "address";
+        }];
+        readonly name: "distributed";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [];
+        readonly name: "duration";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "uint64";
+            readonly type: "uint64";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [];
+        readonly name: "end";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [];
+        readonly name: "getComponentInterface";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "bytes4";
+            readonly type: "bytes4";
+        }];
+        readonly stateMutability: "pure";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "data_";
+            readonly internalType: "bytes";
+            readonly type: "bytes";
+        }];
+        readonly name: "initialize";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "account_";
+            readonly internalType: "address";
+            readonly type: "address";
+        }];
+        readonly name: "isAuthorized";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "bool";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [];
+        readonly name: "owner";
+        readonly outputs: readonly [{
+            readonly name: "result";
+            readonly internalType: "address";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "pendingOwner";
+            readonly internalType: "address";
+            readonly type: "address";
+        }];
+        readonly name: "ownershipHandoverExpiresAt";
+        readonly outputs: readonly [{
+            readonly name: "result";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "";
+            readonly internalType: "bytes";
+            readonly type: "bytes";
+        }];
+        readonly name: "reconcile";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [];
+        readonly name: "renounceOwnership";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [];
+        readonly name: "requestOwnershipHandover";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "account_";
+            readonly internalType: "address[]";
+            readonly type: "address[]";
+        }, {
+            readonly name: "authorized_";
+            readonly internalType: "bool[]";
+            readonly type: "bool[]";
+        }];
+        readonly name: "setAuthorized";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [];
+        readonly name: "start";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "uint64";
+            readonly type: "uint64";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "interfaceId";
+            readonly internalType: "bytes4";
+            readonly type: "bytes4";
+        }];
+        readonly name: "supportsInterface";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "bool";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "asset_";
+            readonly internalType: "address";
+            readonly type: "address";
+        }];
+        readonly name: "total";
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "newOwner";
+            readonly internalType: "address";
+            readonly type: "address";
+        }];
+        readonly name: "transferOwnership";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+    }, {
+        readonly type: "receive";
+        readonly stateMutability: "payable";
+    }];
+    /**
+     * @inheritdoc
+     *
+     * @public
+     * @static
+     * @type {Address}
+     */
+    static base: Address;
+    /**
+     * @inheritdoc
+     *
+     * @public
+     * @static
+     * @type {RegistryType}
+     */
+    static registryType: RegistryType;
+    /**
+     * Get the owner of the budget
+     *
+     * @public
+     * @param {?ReadParams<typeof vestingBudgetAbi, 'owner'>} [params]
+     * @returns {Promise<Address>}
+     */
+    owner(params?: ReadParams<typeof vestingBudgetAbi, 'owner'>): Promise<`0x${string}`>;
+    /**
+     * The timestamp at which the vesting schedule begins
+     *
+     * @public
+     * @param {?ReadParams<typeof vestingBudgetAbi, 'start'>} [params]
+     * @returns {*}
+     */
+    start(params?: ReadParams<typeof vestingBudgetAbi, 'start'>): Promise<bigint>;
+    /**
+     * The duration of the vesting schedule (in seconds)
+     *
+     * @public
+     * @param {?ReadParams<typeof vestingBudgetAbi, 'duration'>} [params]
+     * @returns {*}
+     */
+    duration(params?: ReadParams<typeof vestingBudgetAbi, 'duration'>): Promise<bigint>;
+    /**
+     * The duration of the cliff period (in seconds)
+     *
+     * @public
+     * @param {?ReadParams<typeof vestingBudgetAbi, 'cliff'>} [params]
+     * @returns {*}
+     */
+    cliff(params?: ReadParams<typeof vestingBudgetAbi, 'cliff'>): Promise<bigint>;
+    /**
+     *  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)} transfer
+     * @param {?WriteParams<typeof vestingBudgetAbi, 'allocate'>} [params]
+     * @returns {Promise<boolean>} - True if the allocation was successful
+     */
+    allocate(transfer: FungibleTransferPayload, params?: WriteParams<typeof vestingBudgetAbi, 'allocate'>): Promise<boolean>;
+    /**
+     *  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)} transfer
+     * @param {?WriteParams<typeof vestingBudgetAbi, 'allocate'>} [params]
+     * @returns {Promise<boolean>} - True if the allocation was successful
+     */
+    allocateRaw(transfer: FungibleTransferPayload, params?: WriteParams<typeof vestingBudgetAbi, 'allocate'>): Promise<{
+        hash: `0x${string}`;
+        result: boolean;
+    }>;
+    /**
+     * 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)} transfer
+     * @param {?WriteParams<typeof vestingBudgetAbi, 'clawback'>} [params]
+     * @returns {Promise<boolean>} - True if the request was successful
+     */
+    clawback(transfer: FungibleTransferPayload, params?: WriteParams<typeof vestingBudgetAbi, 'clawback'>): Promise<boolean>;
+    /**
+     * 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)} transfer
+     * @param {?WriteParams<typeof vestingBudgetAbi, 'clawback'>} [params]
+     * @returns {Promise<boolean>} - True if the request was successful
+     */
+    clawbackRaw(transfer: FungibleTransferPayload, params?: WriteParams<typeof vestingBudgetAbi, 'clawback'>): Promise<{
+        hash: `0x${string}`;
+        result: boolean;
+    }>;
+    /**
+     * Disburses assets from the budget to a single recipient
+     * If the asset transfer fails, the disbursement will revert
+     *
+     * @public
+     * @async
+     * @param {(FungibleTransferPayload)} transfer
+     * @param {?WriteParams<typeof vestingBudgetAbi, 'disburse'>} [params]
+     * @returns {Promise<boolean>} - True if the disbursement was successful
+     */
+    disburse(transfer: FungibleTransferPayload, params?: WriteParams<typeof vestingBudgetAbi, 'disburse'>): Promise<boolean>;
+    /**
+     * Disburses assets from the budget to a single recipient
+     * If the asset transfer fails, the disbursement will revert
+     *
+     * @public
+     * @async
+     * @param {(FungibleTransferPayload)} transfer
+     * @param {?WriteParams<typeof vestingBudgetAbi, 'disburse'>} [params]
+     * @returns {Promise<boolean>} - True if the disbursement was successful
+     */
+    disburseRaw(transfer: FungibleTransferPayload, params?: WriteParams<typeof vestingBudgetAbi, 'disburse'>): Promise<{
+        hash: `0x${string}`;
+        result: boolean;
+    }>;
+    /**
+     * Disburses assets from the budget to multiple recipients
+     *
+     * @public
+     * @async
+     * @param {Array<FungibleTransferPayload>} transfers
+     * @param {?WriteParams<typeof vestingBudgetAbi, 'disburseBatch'>} [params]
+     * @returns {Promise<boolean>} - True if all disbursements were successful
+     */
+    disburseBatch(transfers: FungibleTransferPayload[], params?: WriteParams<typeof vestingBudgetAbi, 'disburseBatch'>): Promise<boolean>;
+    /**
+     * Disburses assets from the budget to multiple recipients
+     *
+     * @public
+     * @async
+     * @param {Array<FungibleTransferPayload>} transfers
+     * @param {?WriteParams<typeof vestingBudgetAbi, 'disburseBatch'>} [params]
+     * @returns {Promise<boolean>} - True if all disbursements were successful
+     */
+    disburseBatchRaw(transfers: FungibleTransferPayload[], params?: WriteParams<typeof vestingBudgetAbi, 'disburseBatch'>): Promise<{
+        hash: `0x${string}`;
+        result: boolean;
+    }>;
+    /**
+     * 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>}
+     */
+    setAuthorized(addresses: Address[], allowed: boolean[], params?: WriteParams<typeof vestingBudgetAbi, 'setAuthorized'>): Promise<void>;
+    /**
+     * 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>}
+     */
+    setAuthorizedRaw(addresses: Address[], allowed: boolean[], params?: WriteParams<typeof vestingBudgetAbi, 'setAuthorized'>): Promise<{
+        hash: `0x${string}`;
+        result: void;
+    }>;
+    /**
+     * 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
+     */
+    isAuthorized(account: Address, params?: ReadParams<typeof vestingBudgetAbi, 'isAuthorized'>): Promise<boolean>;
+    /**
+     * Get the end time of the vesting schedule
+     *
+     * @public
+     * @param {?ReadParams<typeof vestingBudgetAbi, 'end'>} [params]
+     * @returns {Promise<bigint>}
+     */
+    end(params?: ReadParams<typeof vestingBudgetAbi, 'end'>): Promise<bigint>;
+    /**
+     * Get the total amount of assets allocated to the budget, including any that have been distributed
+     * This is equal to the sum of the total current balance and the total distributed amount
+     *
+     * @public
+     * @param {Address} asset -  The address of the asset (or the zero address for native assets)
+     * @param {?ReadParams<typeof vestingBudgetAbi, 'total'>} [params]
+     * @returns {Promise<bigint>}
+     */
+    total(asset: Address, params?: ReadParams<typeof vestingBudgetAbi, 'total'>): Promise<bigint>;
+    /**
+     * Get the amount of assets available for distribution from the budget as of the current block timestamp
+     * This is equal to the total vested amount minus any already distributed
+     *
+     * @public
+     * @param {Address} asset -  The address of the asset (or the zero address for native assets)
+     * @param {?ReadParams<typeof vestingBudgetAbi, 'available'>} [params]
+     * @returns {Promise<bigint>} - The amount of assets currently available for distribution
+     */
+    available(asset: Address, params?: ReadParams<typeof vestingBudgetAbi, 'available'>): Promise<bigint>;
+    /**
+     * Get the amount of assets that have been distributed from the budget
+     *
+     * @public
+     * @param {Address} asset
+     * @param {?ReadParams<typeof vestingBudgetAbi, 'distributed'>} [params]
+     * @returns {Promise<bigint>} - The amount of assets distributed
+     */
+    distributed(asset: Address, params?: ReadParams<typeof vestingBudgetAbi, 'distributed'>): Promise<bigint>;
+    /**
+     * @inheritdoc
+     *
+     * @public
+     * @param {?VestingBudgetPayload} [_payload]
+     * @param {?DeployableOptions} [_options]
+     * @returns {GenericDeployableParams}
+     */
+    buildParameters(_payload?: VestingBudgetPayload, _options?: DeployableOptions): GenericDeployableParams;
+}
+/**
+ * Given a {@link VestingBudgetPayload}, properly encode a `VestingBudget.InitPayload` for use with {@link VestingBudget} initialization.
+ *
+ * @param {VestingBudgetPayload} 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.
+ * @param {bigint} param0.start - The timestamp at which the vesting schedule begins
+ * @param {bigint} param0.duration - The duration of the vesting schedule (in seconds)
+ * @param {bigint} param0.cliff - The duration of the cliff period (in seconds)
+ * @returns {Hex}
+ */
+export declare function prepareVestingBudgetPayload({ owner, authorized, start, duration, cliff, }: VestingBudgetPayload): `0x${string}`;
+//# sourceMappingURL=VestingBudget.d.ts.map