@boostxyz/sdk 0.0.0-alpha.2

package/dist/Budgets/VestingBudget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VestingBudget.d.ts","sourceRoot":"","sources":["../../src/Budgets/VestingBudget.ts"],"names":[],"mappings":"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"}

package/dist/Deployable/Contract.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("@wagmi/core"),i=require("viem"),o=require("viem/actions"),d=require("../errors.cjs"),c=require("../utils.cjs");class h{constructor(e,t){this._config=e,this._address=t}get address(){return this._address}at(e){return this._address=e,this}withConfig(e){return this._config=e,this}assertValidAddress(){const e=this.address;if(!e)throw new d.ContractAddressRequiredError;return e}async getLogs(e){return o.getLogs(this._config.getClient({chainId:e==null?void 0:e.chainId}),{...e,...e!=null&&e.eventName?{event:i.getAbiItem({abi:this.abi,name:e.eventName})}:{},...e!=null&&e.eventNames?{events:e.eventNames.map(t=>i.getAbiItem({abi:this.abi,name:t}))}:{},address:this.assertValidAddress()})}async subscribe(e,t){return r.watchContractEvent(this._config,{...t,eventName:t==null?void 0:t.eventName,abi:this.abi,address:this.assertValidAddress(),onLogs:s=>{for(let n of s)e(n)}})}async awaitResult(e,t){return c.awaitResult(this._config,e,t)}}exports.Contract=h;

package/dist/Deployable/Contract.d.ts

@@ -0,0 +1,125 @@
+import { type Config } from '@wagmi/core';
+import type { ExtractAbiEvent } from 'abitype';
+import { type Abi, type Address, type ContractEventName, type GetLogsReturnType, type WaitForTransactionReceiptParameters, type WatchContractEventOnLogsParameter } from 'viem';
+import { type GetLogsParams, type HashAndSimulatedResult, type WatchParams } from '../utils';
+/**
+ * A basic Contract class to encapsulate configuration and a potential address
+ *
+ * @export
+ * @class Contract
+ * @typedef {Contract}
+ * @template {Abi} [ContractAbi=[]]
+ * @template {ContractEventName<ContractAbi>} [ContractEvent=any]
+ */
+export declare class Contract<ContractAbi extends Abi> {
+    readonly abi: ContractAbi;
+    /**
+     * @see [Wagmi Configuration](https://wagmi.sh/core/api/createConfig)
+     * @protected
+     * @type {WagmiConfig}
+     */
+    protected _config: Config;
+    /**
+     * The internally managed address for this contract
+     *
+     * @protected
+     * @type {(Address | undefined)}
+     */
+    protected _address: Address | undefined;
+    /**
+     * Creates an instance of Contract.
+     *
+     * @constructor
+     * @param {Config} config
+     * @param {(Address | undefined)} address
+     */
+    constructor(config: Config, address: Address | undefined);
+    /**
+     * A getter returning this contract's deployed address, if it exists.
+     *
+     * @public
+     * @readonly
+     * @type {*}
+     */
+    get address(): `0x${string}` | undefined;
+    /**
+     * Will set this contract's address and return the instance for chaining. Does not verify that provided address is valid.
+     *
+     * @public
+     * @param {Address} address
+     * @returns {this}
+     */
+    at(address: Address): this;
+    /**
+     * Will set this contract's internal [Wagmi Configuration](https://en.wikipedia.org/wiki/Factorial) and return the instance for chaining.
+     *
+     * @public
+     * @param {Config} config
+     * @returns {this}
+     */
+    withConfig(config: Config): this;
+    /**
+     * Utility function to validate the existence of an address on this Contract.
+     *
+     * @public
+     * @returns {Address}
+     * @throws {@link ContractAddressRequiredError} if no address exists on this Contract instance
+     */
+    assertValidAddress(): `0x${string}`;
+    /**
+     * A typed wrapper for (viem.getLogs)[https://viem.sh/docs/actions/public/getLogs#getlogs].
+     * Accepts `eventName` and `eventNames` as optional parameters to narrow the returned log types.
+     * @example
+     * ```ts
+     * const logs = contract.getLogs({ eventName: 'EventName' })
+     * const logs = contract.getLogs({ eventNames: ['EventName'] })
+     *
+     * @public
+     * @async
+     * @template {ContractEvent} event
+     * @template {ExtractAbiEvent<
+     *       ContractAbi,
+     *       event
+     *     >} [abiEvent=ExtractAbiEvent<ContractAbi, event>]
+     * @param {?Omit<
+     *       GetLogsParams<ContractAbi, event, abiEvent, abiEvent[]>,
+     *       'event' | 'events'
+     *     > & {
+     *       eventName?: event;
+     *       eventNames?: event[];
+     *     }} [params]
+     * @returns {Promise<GetLogsReturnType<abiEvent, abiEvent[]>>}
+     */
+    getLogs<event extends ContractEventName<ContractAbi>, const abiEvent extends ExtractAbiEvent<ContractAbi, event> = ExtractAbiEvent<ContractAbi, event>>(params?: Omit<GetLogsParams<ContractAbi, event, abiEvent, abiEvent[]>, 'event' | 'events'> & {
+        eventName?: event;
+        eventNames?: event[];
+    }): Promise<GetLogsReturnType<abiEvent, abiEvent[]>>;
+    /**
+     * A typed wrapper for `wagmi.watchContractEvent`
+     *
+     * @public
+     * @async
+     * @template {ContractEvent} event
+     * @param {(
+     *       log: WatchContractEventOnLogsParameter<ContractAbi, event, true>[number],
+     *     ) => unknown} cb
+     * @param {?WatchParams<ContractAbi, event> & {
+     *       eventName?: event;
+     *     }} [params]
+     * @returns {unknown, params?: any) => unknown}
+     */
+    subscribe<event extends ContractEventName<ContractAbi>>(cb: (log: WatchContractEventOnLogsParameter<ContractAbi, event, true>[number]) => unknown, params?: WatchParams<ContractAbi, event> & {
+        eventName?: event;
+    }): Promise<() => void>;
+    /**
+     * @see {@link awaitResult}
+     * @protected
+     * @async
+     * @template [Result=unknown]
+     * @param {Promise<HashAndSimulatedResult<Result>>} hashPromise
+     * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams]
+     * @returns {unknown}
+     */
+    protected awaitResult<Result = unknown>(hashPromise: Promise<HashAndSimulatedResult<Result>>, waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>): Promise<Result>;
+}
+//# sourceMappingURL=Contract.d.ts.map

package/dist/Deployable/Contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contract.d.ts","sourceRoot":"","sources":["../../src/Deployable/Contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAsB,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EACL,KAAK,GAAG,EACR,KAAK,OAAO,EACZ,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,mCAAmC,EACxC,KAAK,iCAAiC,EAEvC,MAAM,MAAM,CAAC;AAGd,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAEjB,MAAM,UAAU,CAAC;AAElB;;;;;;;;GAQG;AACH,qBAAa,QAAQ,CAAC,WAAW,SAAS,GAAG;IAE3C,SAAgB,GAAG,EAAE,WAAW,CAAC;IACjC;;;;OAIG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAExC;;;;;;OAMG;gBACS,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,SAAS;IAKxD;;;;;;OAMG;IACH,IAAW,OAAO,8BAEjB;IAED;;;;;;OAMG;IACI,EAAE,CAAC,OAAO,EAAE,OAAO;IAK1B;;;;;;OAMG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM;IAKhC;;;;;;OAMG;IACI,kBAAkB;IAMzB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,OAAO,CAClB,KAAK,SAAS,iBAAiB,CAAC,WAAW,CAAC,EAC5C,KAAK,CAAC,QAAQ,SAAS,eAAe,CACpC,WAAW,EACX,KAAK,CACN,GAAG,eAAe,CAAC,WAAW,EAAE,KAAK,CAAC,EAEvC,MAAM,CAAC,EAAE,IAAI,CACX,aAAa,CAAC,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,EACvD,OAAO,GAAG,QAAQ,CACnB,GAAG;QACF,SAAS,CAAC,EAAE,KAAK,CAAC;QAClB,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC;KACtB,GACA,OAAO,CAAC,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;IA4BnD;;;;;;;;;;;;;OAaG;IACU,SAAS,CAAC,KAAK,SAAS,iBAAiB,CAAC,WAAW,CAAC,EACjE,EAAE,EAAE,CACF,GAAG,EAAE,iCAAiC,CAAC,WAAW,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,KACrE,OAAO,EACZ,MAAM,CAAC,EAAE,WAAW,CAAC,WAAW,EAAE,KAAK,CAAC,GAAG;QACzC,SAAS,CAAC,EAAE,KAAK,CAAC;KACnB;IAqBH;;;;;;;;OAQG;cACa,WAAW,CAAC,MAAM,GAAG,OAAO,EAC1C,WAAW,EAAE,OAAO,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC,EACpD,UAAU,CAAC,EAAE,IAAI,CAAC,mCAAmC,EAAE,MAAM,CAAC;CAIjE"}

package/dist/Deployable/Contract.js

@@ -0,0 +1,149 @@
+import { watchContractEvent as o } from "@wagmi/core";
+import { getAbiItem as i } from "viem";
+import { getLogs as d } from "viem/actions";
+import { ContractAddressRequiredError as r } from "../errors.js";
+import { awaitResult as h } from "../utils.js";
+class v {
+  /**
+   * Creates an instance of Contract.
+   *
+   * @constructor
+   * @param {Config} config
+   * @param {(Address | undefined)} address
+   */
+  constructor(t, e) {
+    this._config = t, this._address = e;
+  }
+  /**
+   * A getter returning this contract's deployed address, if it exists.
+   *
+   * @public
+   * @readonly
+   * @type {*}
+   */
+  get address() {
+    return this._address;
+  }
+  /**
+   * Will set this contract's address and return the instance for chaining. Does not verify that provided address is valid.
+   *
+   * @public
+   * @param {Address} address
+   * @returns {this}
+   */
+  at(t) {
+    return this._address = t, this;
+  }
+  /**
+   * Will set this contract's internal [Wagmi Configuration](https://en.wikipedia.org/wiki/Factorial) and return the instance for chaining.
+   *
+   * @public
+   * @param {Config} config
+   * @returns {this}
+   */
+  withConfig(t) {
+    return this._config = t, this;
+  }
+  /**
+   * Utility function to validate the existence of an address on this Contract.
+   *
+   * @public
+   * @returns {Address}
+   * @throws {@link ContractAddressRequiredError} if no address exists on this Contract instance
+   */
+  assertValidAddress() {
+    const t = this.address;
+    if (!t)
+      throw new r();
+    return t;
+  }
+  /**
+   * A typed wrapper for (viem.getLogs)[https://viem.sh/docs/actions/public/getLogs#getlogs].
+   * Accepts `eventName` and `eventNames` as optional parameters to narrow the returned log types.
+   * @example
+   * ```ts
+   * const logs = contract.getLogs({ eventName: 'EventName' })
+   * const logs = contract.getLogs({ eventNames: ['EventName'] })
+   *
+   * @public
+   * @async
+   * @template {ContractEvent} event
+   * @template {ExtractAbiEvent<
+   *       ContractAbi,
+   *       event
+   *     >} [abiEvent=ExtractAbiEvent<ContractAbi, event>]
+   * @param {?Omit<
+   *       GetLogsParams<ContractAbi, event, abiEvent, abiEvent[]>,
+   *       'event' | 'events'
+   *     > & {
+   *       eventName?: event;
+   *       eventNames?: event[];
+   *     }} [params]
+   * @returns {Promise<GetLogsReturnType<abiEvent, abiEvent[]>>}
+   */
+  async getLogs(t) {
+    return d(this._config.getClient({ chainId: t == null ? void 0 : t.chainId }), {
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wag
+      ...t,
+      ...t != null && t.eventName ? {
+        event: i({
+          abi: this.abi,
+          name: t.eventName
+          // biome-ignore lint/suspicious/noExplicitAny: awkward abi intersection issue
+        })
+      } : {},
+      ...t != null && t.eventNames ? {
+        events: t.eventNames.map(
+          (e) => i({
+            abi: this.abi,
+            name: e
+            // biome-ignore lint/suspicious/noExplicitAny: awkward abi intersection issue
+          })
+        )
+      } : {},
+      address: this.assertValidAddress()
+    });
+  }
+  /**
+   * A typed wrapper for `wagmi.watchContractEvent`
+   *
+   * @public
+   * @async
+   * @template {ContractEvent} event
+   * @param {(
+   *       log: WatchContractEventOnLogsParameter<ContractAbi, event, true>[number],
+   *     ) => unknown} cb
+   * @param {?WatchParams<ContractAbi, event> & {
+   *       eventName?: event;
+   *     }} [params]
+   * @returns {unknown, params?: any) => unknown}
+   */
+  async subscribe(t, e) {
+    return o(this._config, {
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...e,
+      eventName: e == null ? void 0 : e.eventName,
+      abi: this.abi,
+      address: this.assertValidAddress(),
+      onLogs: (s) => {
+        for (let n of s)
+          t(n);
+      }
+    });
+  }
+  /**
+   * @see {@link awaitResult}
+   * @protected
+   * @async
+   * @template [Result=unknown]
+   * @param {Promise<HashAndSimulatedResult<Result>>} hashPromise
+   * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams]
+   * @returns {unknown}
+   */
+  async awaitResult(t, e) {
+    return h(this._config, t, e);
+  }
+}
+export {
+  v as Contract
+};

package/dist/Deployable/Deployable.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("@wagmi/core"),a=require("../errors.cjs"),n=require("../utils.cjs"),c=require("./Contract.cjs");class l extends c.Contract{constructor({account:t,config:e},o){typeof o=="string"?super(e,o):(super(e,void 0),this._payload=o),t&&(this._account=t)}get payload(){return this._payload}withPayload(t){return this._payload=t,this}async deploy(t,e,o){const r=(e==null?void 0:e.config)||this._config,i=await n.getDeployedContractAddress(r,this.deployRaw(t,e),o);return this._address=i,this}async deployRaw(t,e){if(this.address)throw new a.DeployableAlreadyDeployedError(this.address);const[o,r]=this.validateDeploymentConfig(t,e);return await s.deployContract(r.config,{...this.buildParameters(o),...this.optionallyAttachAccount(r.account)})}optionallyAttachAccount(t){return t?{account:t}:this._account?{account:this._account}:{}}buildParameters(t,e){throw new a.DeployableBuildParametersUnspecifiedError}validateDeploymentConfig(t,e){const o=e||{config:this._config,account:this._account};if(!o)throw new a.DeployableWagmiConfigurationRequiredError;return[t||this._payload,o]}}exports.Deployable=l;

package/dist/Deployable/Deployable.d.ts

@@ -0,0 +1,155 @@
+import { type Config, deployContract } from '@wagmi/core';
+import type { Abi, Account, Address, Hash, Hex, WaitForTransactionReceiptParameters } from 'viem';
+import { Contract } from './Contract';
+/**
+ * A base class representing a deployable contract, contains base implementations for deployment and initialization payload construction.
+ *
+ * @export
+ * @typedef {GenericDeployableParams}
+ */
+export type GenericDeployableParams = Omit<Parameters<typeof deployContract>[1], 'args' | 'account'> & {
+    args: [Hex, ...Array<Hex>];
+    account?: Account;
+};
+/**
+ * A generic type that encapsulates either an initialization payload for a contract, or a valid address for a previously deployed contract.
+ *
+ * @export
+ * @typedef {DeployablePayloadOrAddress}
+ * @template [Payload=unknown]
+ */
+export type DeployablePayloadOrAddress<Payload = unknown> = Payload | Address;
+/**
+ * Instantion options for the base deployable.
+ *
+ * @export
+ * @interface DeployableOptions
+ * @typedef {DeployableOptions}
+ */
+export interface DeployableOptions {
+    /**
+     * [Wagmi Configuration](https://wagmi.sh/core/api/createConfig)
+     *
+     * @see {@link Config}
+     * @type {Config}
+     */
+    config: Config;
+    /**
+     * [Viem Local Account](https://viem.sh/docs/accounts/local), required if in a Node environment
+     *
+     * @see {@link Account}
+     * @type {?Account}
+     */
+    account?: Account;
+}
+/**
+ * A generic deployable contract that encapsulates common operations related to contract deployment
+ *
+ * @export
+ * @class Deployable
+ * @typedef {Deployable}
+ * @template [Payload=unknown]
+ * @template {Abi} [ContractAbi=[]]
+ * @template {ContractEventName<ContractAbi>} [ContractEvent=ContractEventName<ContractAbi>]
+ * @extends {Contract<ContractAbi, ContractEvent>}
+ */
+export declare class Deployable<Payload, ContractAbi extends Abi> extends Contract<ContractAbi> {
+    /**
+     * The deployable payload used either for contract construction or initialization
+     *
+     * @protected
+     * @type {(Payload | undefined)}
+     */
+    protected _payload: Payload | undefined;
+    /**
+     * If it exists, [Viem Local Account](https://viem.sh/docs/accounts/local), if in a Node environment
+     *
+     * @protected
+     * @type {?Account}
+     */
+    protected _account?: Account;
+    /**
+     * Creates an instance of Deployable.
+     *
+     * @constructor
+     * @param {DeployableOptions} param0
+     * @param {?Account} [param0.account]
+     * @param {Config} param0.config
+     * @param {DeployablePayloadOrAddress<Payload>} payload
+     */
+    constructor({ account, config }: DeployableOptions, payload?: DeployablePayloadOrAddress<Payload>);
+    /**
+     * Returns the attached deployable payload, if it exists
+     *
+     * @readonly
+     * @type {Payload}
+     */
+    get payload(): Payload | undefined;
+    /**
+     * Attaches a new payload for use with this deployable's initialization
+     *
+     * @public
+     * @param {Payload} payload
+     * @returns {this}
+     */
+    withPayload(payload: Payload): this;
+    /**
+     * High level deployment function to deploy and await the contract address.
+     *
+     * @public
+     * @async
+     * @param {?Payload} [_payload]
+     * @param {?DeployableOptions} [_options]
+     * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams] - See [viem.WaitForTransactionReceipt](https://v1.viem.sh/docs/actions/public/waitForTransactionReceipt.html#waitfortransactionreceipt)
+     * @returns {unknown}
+     */
+    deploy(_payload?: Payload, _options?: DeployableOptions, waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>): Promise<this>;
+    /**
+     * The lower level contract deployment function that does not await for the transaction receipt.
+     *
+     * @public
+     * @async
+     * @param {?Payload} [_payload]
+     * @param {?DeployableOptions} [_options]
+     * @returns {Promise<Hash>}
+     * @throws {@link DeployableAlreadyDeployedError}
+     * @throws {@link DeployableWagmiConfigurationRequiredError}
+     * @throws {@link DeployableMissingPayloadError}
+     */
+    deployRaw(_payload?: Payload, _options?: DeployableOptions): Promise<Hash>;
+    /**
+     * Internal function to attach the connected account to write methods to avoid manually passing in an account each call.
+     *
+     * @protected
+     * @param {?Account} [account]
+     * @returns {({ account: Account; } | { account?: undefined; })}
+     */
+    protected optionallyAttachAccount(account?: Account): {
+        account: Account;
+    } | {
+        account?: undefined;
+    };
+    /**
+     * Base parameter constructor, should return a partial `viem.deployContract` parameters shape including abi, bytecode, and arguments, if any.
+     * Expected to be overridden by protocol contracts.
+     *
+     * @public
+     * @param {?Payload} [_payload]
+     * @param {?DeployableOptions} [_options]
+     * @returns {GenericDeployableParams}
+     */
+    buildParameters(_payload?: Payload, _options?: DeployableOptions): GenericDeployableParams;
+    /**
+     * Internal method used to ensure that a Wagmi configuration and payload are always present when deploying.
+     *
+     * @protected
+     * @template [P=Payload]
+     * @param {?P} [_payload]
+     * @param {?DeployableOptions} [_options]
+     * @returns {[P, DeployableOptions]}
+     * @throws {@link DeployableWagmiConfigurationRequiredError}
+     * @throws {@link DeployableMissingPayloadError}
+     */
+    protected validateDeploymentConfig<P = Payload>(_payload?: P, _options?: DeployableOptions): [P, DeployableOptions];
+}
+//# sourceMappingURL=Deployable.d.ts.map

package/dist/Deployable/Deployable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Deployable.d.ts","sourceRoot":"","sources":["../../src/Deployable/Deployable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EACV,GAAG,EACH,OAAO,EACP,OAAO,EAEP,IAAI,EACJ,GAAG,EACH,mCAAmC,EACpC,MAAM,MAAM,CAAC;AAQd,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACxC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,CAAC,EACpC,MAAM,GAAG,SAAS,CACnB,GAAG;IACF,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,0BAA0B,CAAC,OAAO,GAAG,OAAO,IAAI,OAAO,GAAG,OAAO,CAAC;AAE9E;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,UAAU,CACrB,OAAO,EACP,WAAW,SAAS,GAAG,CACvB,SAAQ,QAAQ,CAAC,WAAW,CAAC;IAC7B;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACxC;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAE7B;;;;;;;;OAQG;gBAED,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,iBAAiB,EACtC,OAAO,CAAC,EAAE,0BAA0B,CAAC,OAAO,CAAC;IAW/C;;;;;OAKG;IACH,IAAI,OAAO,wBAEV;IAED;;;;;;OAMG;IACI,WAAW,CAAC,OAAO,EAAE,OAAO;IAKnC;;;;;;;;;OASG;IACU,MAAM,CACjB,QAAQ,CAAC,EAAE,OAAO,EAClB,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,UAAU,CAAC,EAAE,IAAI,CAAC,mCAAmC,EAAE,MAAM,CAAC;IAYhE;;;;;;;;;;;OAWG;IACU,SAAS,CACpB,QAAQ,CAAC,EAAE,OAAO,EAClB,QAAQ,CAAC,EAAE,iBAAiB,GAC3B,OAAO,CAAC,IAAI,CAAC;IAYhB;;;;;;OAMG;IACH,SAAS,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE,OAAO;;;;;IAKnD;;;;;;;;OAQG;IACI,eAAe,CACpB,QAAQ,CAAC,EAAE,OAAO,EAClB,QAAQ,CAAC,EAAE,iBAAiB,GAC3B,uBAAuB;IAI1B;;;;;;;;;;OAUG;IACH,SAAS,CAAC,wBAAwB,CAAC,CAAC,GAAG,OAAO,EAC5C,QAAQ,CAAC,EAAE,CAAC,EACZ,QAAQ,CAAC,EAAE,iBAAiB;CAU/B"}

package/dist/Deployable/Deployable.js

@@ -0,0 +1,124 @@
+import { deployContract as i } from "@wagmi/core";
+import { DeployableAlreadyDeployedError as s, DeployableBuildParametersUnspecifiedError as n, DeployableWagmiConfigurationRequiredError as l } from "../errors.js";
+import { getDeployedContractAddress as c } from "../utils.js";
+import { Contract as d } from "./Contract.js";
+class m extends d {
+  /**
+   * Creates an instance of Deployable.
+   *
+   * @constructor
+   * @param {DeployableOptions} param0
+   * @param {?Account} [param0.account]
+   * @param {Config} param0.config
+   * @param {DeployablePayloadOrAddress<Payload>} payload
+   */
+  constructor({ account: t, config: o }, a) {
+    typeof a == "string" ? super(o, a) : (super(o, void 0), this._payload = a), t && (this._account = t);
+  }
+  /**
+   * Returns the attached deployable payload, if it exists
+   *
+   * @readonly
+   * @type {Payload}
+   */
+  get payload() {
+    return this._payload;
+  }
+  /**
+   * Attaches a new payload for use with this deployable's initialization
+   *
+   * @public
+   * @param {Payload} payload
+   * @returns {this}
+   */
+  withPayload(t) {
+    return this._payload = t, this;
+  }
+  /**
+   * High level deployment function to deploy and await the contract address.
+   *
+   * @public
+   * @async
+   * @param {?Payload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams] - See [viem.WaitForTransactionReceipt](https://v1.viem.sh/docs/actions/public/waitForTransactionReceipt.html#waitfortransactionreceipt)
+   * @returns {unknown}
+   */
+  async deploy(t, o, a) {
+    const e = (o == null ? void 0 : o.config) || this._config, r = await c(
+      e,
+      this.deployRaw(t, o),
+      a
+    );
+    return this._address = r, this;
+  }
+  /**
+   * The lower level contract deployment function that does not await for the transaction receipt.
+   *
+   * @public
+   * @async
+   * @param {?Payload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {Promise<Hash>}
+   * @throws {@link DeployableAlreadyDeployedError}
+   * @throws {@link DeployableWagmiConfigurationRequiredError}
+   * @throws {@link DeployableMissingPayloadError}
+   */
+  async deployRaw(t, o) {
+    if (this.address)
+      throw new s(this.address);
+    const [a, e] = this.validateDeploymentConfig(
+      t,
+      o
+    );
+    return await i(e.config, {
+      ...this.buildParameters(a),
+      ...this.optionallyAttachAccount(e.account)
+    });
+  }
+  /**
+   * Internal function to attach the connected account to write methods to avoid manually passing in an account each call.
+   *
+   * @protected
+   * @param {?Account} [account]
+   * @returns {({ account: Account; } | { account?: undefined; })}
+   */
+  optionallyAttachAccount(t) {
+    return t ? { account: t } : this._account ? { account: this._account } : {};
+  }
+  /**
+   * Base parameter constructor, should return a partial `viem.deployContract` parameters shape including abi, bytecode, and arguments, if any.
+   * Expected to be overridden by protocol contracts.
+   *
+   * @public
+   * @param {?Payload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  buildParameters(t, o) {
+    throw new n();
+  }
+  /**
+   * Internal method used to ensure that a Wagmi configuration and payload are always present when deploying.
+   *
+   * @protected
+   * @template [P=Payload]
+   * @param {?P} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {[P, DeployableOptions]}
+   * @throws {@link DeployableWagmiConfigurationRequiredError}
+   * @throws {@link DeployableMissingPayloadError}
+   */
+  validateDeploymentConfig(t, o) {
+    const a = o || {
+      config: this._config,
+      account: this._account
+    };
+    if (!a)
+      throw new l();
+    return [t || this._payload, a];
+  }
+}
+export {
+  m as Deployable
+};

package/dist/Deployable/DeployableTarget.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("../generated-BaaleHW-.cjs"),d=require("@wagmi/core"),l=require("viem"),n=require("../errors.cjs"),y=require("../utils.cjs"),u=require("./Deployable.cjs"),s=class s extends u.Deployable{constructor(t,e,r){super(t,e),this.isBase=!0,r!==void 0&&(this.isBase=r)}get base(){return this.constructor.base}get registryType(){return this.constructor.registryType}async deploy(t,e,r){return await super.deploy(t,e,r),this.assertValidAddress(),this}async deployRaw(t,e){if(this.address)throw new n.DeployableAlreadyDeployedError(this.address);const r=t||this._payload,o=(e==null?void 0:e.config)||this._config,{args:h,...c}=this.buildParameters(r);return await d.deployContract(o,{...c,...this.optionallyAttachAccount(e==null?void 0:e.account),args:[]})}async supportsInterface(t,e){return i.Xn(this._config,{address:this.assertValidAddress(),...this.optionallyAttachAccount(),...e,args:[t]})}async getComponentInterface(t){return i.Kn(this._config,{address:this.assertValidAddress(),...this.optionallyAttachAccount(),...t,args:[]})}validateDeploymentConfig(t,e){const r=t||this._payload;if(!r)throw new n.DeployableMissingPayloadError;return super.validateDeploymentConfig(r,e)}};s.base=l.zeroAddress,s.registryType=y.RegistryType.ACTION;let a=s;exports.DeployableTarget=a;