@boostxyz/sdk 0.0.0-alpha.10

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,2 @@
+"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 await c.awaitResult(this._config,e,t)}}exports.Contract=h;
+//# sourceMappingURL=Contract.cjs.map

package/dist/Deployable/Contract.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contract.cjs","sources":["../../src/Deployable/Contract.ts"],"sourcesContent":["import { type Config, watchContractEvent } from '@wagmi/core';\nimport type { ExtractAbiEvent } from 'abitype';\nimport {\n  type Abi,\n  type Address,\n  type ContractEventName,\n  type GetLogsReturnType,\n  type WaitForTransactionReceiptParameters,\n  type WatchContractEventOnLogsParameter,\n  getAbiItem,\n} from 'viem';\nimport { getLogs } from 'viem/actions';\nimport { ContractAddressRequiredError } from '../errors';\nimport {\n  type GetLogsParams,\n  type HashAndSimulatedResult,\n  type WatchParams,\n  awaitResult,\n} from '../utils';\n\n/**\n * A basic Contract class to encapsulate configuration and a potential address\n *\n * @export\n * @class Contract\n * @typedef {Contract}\n * @template {Abi} [ContractAbi=[]]\n * @template {ContractEventName<ContractAbi>} [ContractEvent=any]\n */\nexport class Contract<ContractAbi extends Abi> {\n  //@ts-expect-error this should always be set by implementing contract\n  public readonly abi: ContractAbi;\n  /**\n   * @see [Wagmi Configuration](https://wagmi.sh/core/api/createConfig)\n   * @protected\n   * @type {WagmiConfig}\n   */\n  protected _config: Config;\n  /**\n   * The internally managed address for this contract\n   *\n   * @protected\n   * @type {(Address | undefined)}\n   */\n  protected _address: Address | undefined;\n\n  /**\n   * Creates an instance of Contract.\n   *\n   * @constructor\n   * @param {Config} config\n   * @param {(Address | undefined)} address\n   */\n  constructor(config: Config, address: Address | undefined) {\n    this._config = config;\n    this._address = address;\n  }\n\n  /**\n   * A getter returning this contract's deployed address, if it exists.\n   *\n   * @public\n   * @readonly\n   * @type {*}\n   */\n  public get address() {\n    return this._address;\n  }\n\n  /**\n   * Will set this contract's address and return the instance for chaining. Does not verify that provided address is valid.\n   *\n   * @public\n   * @param {Address} address\n   * @returns {this}\n   */\n  public at(address: Address) {\n    this._address = address;\n    return this;\n  }\n\n  /**\n   * Will set this contract's internal [Wagmi Configuration](https://en.wikipedia.org/wiki/Factorial) and return the instance for chaining.\n   *\n   * @public\n   * @param {Config} config\n   * @returns {this}\n   */\n  public withConfig(config: Config) {\n    this._config = config;\n    return this;\n  }\n\n  /**\n   * Utility function to validate the existence of an address on this Contract.\n   *\n   * @public\n   * @returns {Address}\n   * @throws {@link ContractAddressRequiredError} if no address exists on this Contract instance\n   */\n  public assertValidAddress() {\n    const address = this.address;\n    if (!address) throw new ContractAddressRequiredError();\n    return address;\n  }\n\n  /**\n   * A typed wrapper for (viem.getLogs)[https://viem.sh/docs/actions/public/getLogs#getlogs].\n   * Accepts `eventName` and `eventNames` as optional parameters to narrow the returned log types.\n   * @example\n   * ```ts\n   * const logs = contract.getLogs({ eventName: 'EventName' })\n   * const logs = contract.getLogs({ eventNames: ['EventName'] })\n   *\n   * @public\n   * @async\n   * @template {ContractEvent} event\n   * @template {ExtractAbiEvent<\n   *       ContractAbi,\n   *       event\n   *     >} [abiEvent=ExtractAbiEvent<ContractAbi, event>]\n   * @param {?Omit<\n   *       GetLogsParams<ContractAbi, event, abiEvent, abiEvent[]>,\n   *       'event' | 'events'\n   *     > & {\n   *       eventName?: event;\n   *       eventNames?: event[];\n   *     }} [params]\n   * @returns {Promise<GetLogsReturnType<abiEvent, abiEvent[]>>}\n   */\n  public async getLogs<\n    event extends ContractEventName<ContractAbi>,\n    const abiEvent extends ExtractAbiEvent<\n      ContractAbi,\n      event\n    > = ExtractAbiEvent<ContractAbi, event>,\n  >(\n    params?: Omit<\n      GetLogsParams<ContractAbi, event, abiEvent, abiEvent[]>,\n      'event' | 'events'\n    > & {\n      eventName?: event;\n      eventNames?: event[];\n    },\n  ): Promise<GetLogsReturnType<abiEvent, abiEvent[]>> {\n    return getLogs(this._config.getClient({ chainId: params?.chainId }), {\n      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wag\n      ...(params as any),\n      ...(params?.eventName\n        ? {\n            event: getAbiItem({\n              abi: this.abi,\n              name: params.eventName,\n              // biome-ignore lint/suspicious/noExplicitAny: awkward abi intersection issue\n            } as any),\n          }\n        : {}),\n      ...(params?.eventNames\n        ? {\n            events: params.eventNames.map((name) =>\n              getAbiItem({\n                abi: this.abi,\n                name,\n                // biome-ignore lint/suspicious/noExplicitAny: awkward abi intersection issue\n              } as any),\n            ),\n          }\n        : {}),\n      address: this.assertValidAddress(),\n    });\n  }\n\n  /**\n   * A typed wrapper for `wagmi.watchContractEvent`\n   *\n   * @public\n   * @async\n   * @template {ContractEvent} event\n   * @param {(\n   *       log: WatchContractEventOnLogsParameter<ContractAbi, event, true>[number],\n   *     ) => unknown} cb\n   * @param {?WatchParams<ContractAbi, event> & {\n   *       eventName?: event;\n   *     }} [params]\n   * @returns {unknown, params?: any) => unknown}\n   */\n  public async subscribe<event extends ContractEventName<ContractAbi>>(\n    cb: (\n      log: WatchContractEventOnLogsParameter<ContractAbi, event, true>[number],\n    ) => unknown,\n    params?: WatchParams<ContractAbi, event> & {\n      eventName?: event;\n    },\n  ) {\n    return watchContractEvent<\n      typeof this._config,\n      (typeof this._config)['chains'][number]['id'],\n      ContractAbi,\n      event\n    >(this._config, {\n      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally\n      ...(params as any),\n      eventName: params?.eventName,\n      abi: this.abi,\n      address: this.assertValidAddress(),\n      onLogs: (logs) => {\n        for (let l of logs) {\n          cb(l);\n        }\n      },\n    });\n  }\n\n  /**\n   * @see {@link awaitResult}\n   * @protected\n   * @async\n   * @template [Result=unknown]\n   * @param {Promise<HashAndSimulatedResult<Result>>} hashPromise\n   * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams]\n   * @returns {unknown}\n   */\n  protected async awaitResult<Result = unknown>(\n    hashPromise: Promise<HashAndSimulatedResult<Result>>,\n    waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,\n  ) {\n    return await awaitResult(this._config, hashPromise, waitParams);\n  }\n}\n"],"names":["Contract","config","address","ContractAddressRequiredError","params","getLogs","getAbiItem","name","cb","watchContractEvent","logs","l","hashPromise","waitParams","awaitResult"],"mappings":"gNA6BO,MAAMA,CAAkC,CAwB7C,YAAYC,EAAgBC,EAA8B,CACxD,KAAK,QAAUD,EACf,KAAK,SAAWC,CAClB,CASA,IAAW,SAAU,CACnB,OAAO,KAAK,QACd,CASO,GAAGA,EAAkB,CAC1B,YAAK,SAAWA,EACT,IACT,CASO,WAAWD,EAAgB,CAChC,YAAK,QAAUA,EACR,IACT,CASO,oBAAqB,CAC1B,MAAMC,EAAU,KAAK,QACrB,GAAI,CAACA,EAAS,MAAM,IAAIC,EAA6B,6BAC9C,OAAAD,CACT,CA0BA,MAAa,QAOXE,EAOkD,CAC3C,OAAAC,EAAA,QAAQ,KAAK,QAAQ,UAAU,CAAE,QAASD,GAAA,YAAAA,EAAQ,OAAQ,CAAC,EAAG,CAEnE,GAAIA,EACJ,GAAIA,GAAA,MAAAA,EAAQ,UACR,CACE,MAAOE,EAAAA,WAAW,CAChB,IAAK,KAAK,IACV,KAAMF,EAAO,SAAA,CAEP,CAAA,EAEV,CAAC,EACL,GAAIA,GAAA,MAAAA,EAAQ,WACR,CACE,OAAQA,EAAO,WAAW,IAAKG,GAC7BD,EAAAA,WAAW,CACT,IAAK,KAAK,IACV,KAAAC,CAAA,CAEM,CACV,CAAA,EAEF,CAAC,EACL,QAAS,KAAK,mBAAmB,CAAA,CAClC,CACH,CAgBA,MAAa,UACXC,EAGAJ,EAGA,CACO,OAAAK,EAAA,mBAKL,KAAK,QAAS,CAEd,GAAIL,EACJ,UAAWA,GAAA,YAAAA,EAAQ,UACnB,IAAK,KAAK,IACV,QAAS,KAAK,mBAAmB,EACjC,OAASM,GAAS,CAChB,QAASC,KAAKD,EACZF,EAAGG,CAAC,CAER,CAAA,CACD,CACH,CAWA,MAAgB,YACdC,EACAC,EACA,CACA,OAAO,MAAMC,EAAA,YAAY,KAAK,QAASF,EAAaC,CAAU,CAChE,CACF"}

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,150 @@
+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 await h(this._config, t, e);
+  }
+}
+export {
+  v as Contract
+};
+//# sourceMappingURL=Contract.js.map

package/dist/Deployable/Contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contract.js","sources":["../../src/Deployable/Contract.ts"],"sourcesContent":["import { type Config, watchContractEvent } from '@wagmi/core';\nimport type { ExtractAbiEvent } from 'abitype';\nimport {\n  type Abi,\n  type Address,\n  type ContractEventName,\n  type GetLogsReturnType,\n  type WaitForTransactionReceiptParameters,\n  type WatchContractEventOnLogsParameter,\n  getAbiItem,\n} from 'viem';\nimport { getLogs } from 'viem/actions';\nimport { ContractAddressRequiredError } from '../errors';\nimport {\n  type GetLogsParams,\n  type HashAndSimulatedResult,\n  type WatchParams,\n  awaitResult,\n} from '../utils';\n\n/**\n * A basic Contract class to encapsulate configuration and a potential address\n *\n * @export\n * @class Contract\n * @typedef {Contract}\n * @template {Abi} [ContractAbi=[]]\n * @template {ContractEventName<ContractAbi>} [ContractEvent=any]\n */\nexport class Contract<ContractAbi extends Abi> {\n  //@ts-expect-error this should always be set by implementing contract\n  public readonly abi: ContractAbi;\n  /**\n   * @see [Wagmi Configuration](https://wagmi.sh/core/api/createConfig)\n   * @protected\n   * @type {WagmiConfig}\n   */\n  protected _config: Config;\n  /**\n   * The internally managed address for this contract\n   *\n   * @protected\n   * @type {(Address | undefined)}\n   */\n  protected _address: Address | undefined;\n\n  /**\n   * Creates an instance of Contract.\n   *\n   * @constructor\n   * @param {Config} config\n   * @param {(Address | undefined)} address\n   */\n  constructor(config: Config, address: Address | undefined) {\n    this._config = config;\n    this._address = address;\n  }\n\n  /**\n   * A getter returning this contract's deployed address, if it exists.\n   *\n   * @public\n   * @readonly\n   * @type {*}\n   */\n  public get address() {\n    return this._address;\n  }\n\n  /**\n   * Will set this contract's address and return the instance for chaining. Does not verify that provided address is valid.\n   *\n   * @public\n   * @param {Address} address\n   * @returns {this}\n   */\n  public at(address: Address) {\n    this._address = address;\n    return this;\n  }\n\n  /**\n   * Will set this contract's internal [Wagmi Configuration](https://en.wikipedia.org/wiki/Factorial) and return the instance for chaining.\n   *\n   * @public\n   * @param {Config} config\n   * @returns {this}\n   */\n  public withConfig(config: Config) {\n    this._config = config;\n    return this;\n  }\n\n  /**\n   * Utility function to validate the existence of an address on this Contract.\n   *\n   * @public\n   * @returns {Address}\n   * @throws {@link ContractAddressRequiredError} if no address exists on this Contract instance\n   */\n  public assertValidAddress() {\n    const address = this.address;\n    if (!address) throw new ContractAddressRequiredError();\n    return address;\n  }\n\n  /**\n   * A typed wrapper for (viem.getLogs)[https://viem.sh/docs/actions/public/getLogs#getlogs].\n   * Accepts `eventName` and `eventNames` as optional parameters to narrow the returned log types.\n   * @example\n   * ```ts\n   * const logs = contract.getLogs({ eventName: 'EventName' })\n   * const logs = contract.getLogs({ eventNames: ['EventName'] })\n   *\n   * @public\n   * @async\n   * @template {ContractEvent} event\n   * @template {ExtractAbiEvent<\n   *       ContractAbi,\n   *       event\n   *     >} [abiEvent=ExtractAbiEvent<ContractAbi, event>]\n   * @param {?Omit<\n   *       GetLogsParams<ContractAbi, event, abiEvent, abiEvent[]>,\n   *       'event' | 'events'\n   *     > & {\n   *       eventName?: event;\n   *       eventNames?: event[];\n   *     }} [params]\n   * @returns {Promise<GetLogsReturnType<abiEvent, abiEvent[]>>}\n   */\n  public async getLogs<\n    event extends ContractEventName<ContractAbi>,\n    const abiEvent extends ExtractAbiEvent<\n      ContractAbi,\n      event\n    > = ExtractAbiEvent<ContractAbi, event>,\n  >(\n    params?: Omit<\n      GetLogsParams<ContractAbi, event, abiEvent, abiEvent[]>,\n      'event' | 'events'\n    > & {\n      eventName?: event;\n      eventNames?: event[];\n    },\n  ): Promise<GetLogsReturnType<abiEvent, abiEvent[]>> {\n    return getLogs(this._config.getClient({ chainId: params?.chainId }), {\n      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wag\n      ...(params as any),\n      ...(params?.eventName\n        ? {\n            event: getAbiItem({\n              abi: this.abi,\n              name: params.eventName,\n              // biome-ignore lint/suspicious/noExplicitAny: awkward abi intersection issue\n            } as any),\n          }\n        : {}),\n      ...(params?.eventNames\n        ? {\n            events: params.eventNames.map((name) =>\n              getAbiItem({\n                abi: this.abi,\n                name,\n                // biome-ignore lint/suspicious/noExplicitAny: awkward abi intersection issue\n              } as any),\n            ),\n          }\n        : {}),\n      address: this.assertValidAddress(),\n    });\n  }\n\n  /**\n   * A typed wrapper for `wagmi.watchContractEvent`\n   *\n   * @public\n   * @async\n   * @template {ContractEvent} event\n   * @param {(\n   *       log: WatchContractEventOnLogsParameter<ContractAbi, event, true>[number],\n   *     ) => unknown} cb\n   * @param {?WatchParams<ContractAbi, event> & {\n   *       eventName?: event;\n   *     }} [params]\n   * @returns {unknown, params?: any) => unknown}\n   */\n  public async subscribe<event extends ContractEventName<ContractAbi>>(\n    cb: (\n      log: WatchContractEventOnLogsParameter<ContractAbi, event, true>[number],\n    ) => unknown,\n    params?: WatchParams<ContractAbi, event> & {\n      eventName?: event;\n    },\n  ) {\n    return watchContractEvent<\n      typeof this._config,\n      (typeof this._config)['chains'][number]['id'],\n      ContractAbi,\n      event\n    >(this._config, {\n      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally\n      ...(params as any),\n      eventName: params?.eventName,\n      abi: this.abi,\n      address: this.assertValidAddress(),\n      onLogs: (logs) => {\n        for (let l of logs) {\n          cb(l);\n        }\n      },\n    });\n  }\n\n  /**\n   * @see {@link awaitResult}\n   * @protected\n   * @async\n   * @template [Result=unknown]\n   * @param {Promise<HashAndSimulatedResult<Result>>} hashPromise\n   * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams]\n   * @returns {unknown}\n   */\n  protected async awaitResult<Result = unknown>(\n    hashPromise: Promise<HashAndSimulatedResult<Result>>,\n    waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,\n  ) {\n    return await awaitResult(this._config, hashPromise, waitParams);\n  }\n}\n"],"names":["Contract","config","address","ContractAddressRequiredError","params","getLogs","getAbiItem","name","cb","watchContractEvent","logs","l","hashPromise","waitParams","awaitResult"],"mappings":";;;;;AA6BO,MAAMA,EAAkC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAwB7C,YAAYC,GAAgBC,GAA8B;AACxD,SAAK,UAAUD,GACf,KAAK,WAAWC;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,IAAW,UAAU;AACnB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,GAAGA,GAAkB;AAC1B,gBAAK,WAAWA,GACT;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,WAAWD,GAAgB;AAChC,gBAAK,UAAUA,GACR;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,qBAAqB;AAC1B,UAAMC,IAAU,KAAK;AACrB,QAAI,CAACA;AAAS,YAAM,IAAIC,EAA6B;AAC9C,WAAAD;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA0BA,MAAa,QAOXE,GAOkD;AAC3C,WAAAC,EAAQ,KAAK,QAAQ,UAAU,EAAE,SAASD,KAAA,gBAAAA,EAAQ,QAAQ,CAAC,GAAG;AAAA;AAAA,MAEnE,GAAIA;AAAA,MACJ,GAAIA,KAAA,QAAAA,EAAQ,YACR;AAAA,QACE,OAAOE,EAAW;AAAA,UAChB,KAAK,KAAK;AAAA,UACV,MAAMF,EAAO;AAAA;AAAA,QAAA,CAEP;AAAA,MAAA,IAEV,CAAC;AAAA,MACL,GAAIA,KAAA,QAAAA,EAAQ,aACR;AAAA,QACE,QAAQA,EAAO,WAAW;AAAA,UAAI,CAACG,MAC7BD,EAAW;AAAA,YACT,KAAK,KAAK;AAAA,YACV,MAAAC;AAAA;AAAA,UAAA,CAEM;AAAA,QACV;AAAA,MAAA,IAEF,CAAC;AAAA,MACL,SAAS,KAAK,mBAAmB;AAAA,IAAA,CAClC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBA,MAAa,UACXC,GAGAJ,GAGA;AACO,WAAAK,EAKL,KAAK,SAAS;AAAA;AAAA,MAEd,GAAIL;AAAA,MACJ,WAAWA,KAAA,gBAAAA,EAAQ;AAAA,MACnB,KAAK,KAAK;AAAA,MACV,SAAS,KAAK,mBAAmB;AAAA,MACjC,QAAQ,CAACM,MAAS;AAChB,iBAASC,KAAKD;AACZ,UAAAF,EAAGG,CAAC;AAAA,MAER;AAAA,IAAA,CACD;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAgB,YACdC,GACAC,GACA;AACA,WAAO,MAAMC,EAAY,KAAK,SAASF,GAAaC,CAAU;AAAA,EAChE;AACF;"}

package/dist/Deployable/Deployable.cjs

@@ -0,0 +1,2 @@
+"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;
+//# sourceMappingURL=Deployable.cjs.map

package/dist/Deployable/Deployable.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Deployable.cjs","sources":["../../src/Deployable/Deployable.ts"],"sourcesContent":["import { type Config, deployContract } from '@wagmi/core';\nimport type {\n  Abi,\n  Account,\n  Address,\n  ContractEventName,\n  Hash,\n  Hex,\n  WaitForTransactionReceiptParameters,\n} from 'viem';\nimport {\n  DeployableAlreadyDeployedError,\n  DeployableBuildParametersUnspecifiedError,\n  DeployableMissingPayloadError,\n  DeployableWagmiConfigurationRequiredError,\n} from '../errors';\nimport { getDeployedContractAddress } from '../utils';\nimport { Contract } from './Contract';\n\n/**\n * A base class representing a deployable contract, contains base implementations for deployment and initialization payload construction.\n *\n * @export\n * @typedef {GenericDeployableParams}\n */\nexport type GenericDeployableParams = Omit<\n  Parameters<typeof deployContract>[1],\n  'args' | 'account'\n> & {\n  args: [Hex, ...Array<Hex>];\n  account?: Account;\n};\n\n/**\n * A generic type that encapsulates either an initialization payload for a contract, or a valid address for a previously deployed contract.\n *\n * @export\n * @typedef {DeployablePayloadOrAddress}\n * @template [Payload=unknown]\n */\nexport type DeployablePayloadOrAddress<Payload = unknown> = Payload | Address;\n\n/**\n * Instantion options for the base deployable.\n *\n * @export\n * @interface DeployableOptions\n * @typedef {DeployableOptions}\n */\nexport interface DeployableOptions {\n  /**\n   * [Wagmi Configuration](https://wagmi.sh/core/api/createConfig)\n   *\n   * @see {@link Config}\n   * @type {Config}\n   */\n  config: Config;\n  /**\n   * [Viem Local Account](https://viem.sh/docs/accounts/local), required if in a Node environment\n   *\n   * @see {@link Account}\n   * @type {?Account}\n   */\n  account?: Account;\n}\n\n/**\n * A generic deployable contract that encapsulates common operations related to contract deployment\n *\n * @export\n * @class Deployable\n * @typedef {Deployable}\n * @template [Payload=unknown]\n * @template {Abi} [ContractAbi=[]]\n * @template {ContractEventName<ContractAbi>} [ContractEvent=ContractEventName<ContractAbi>]\n * @extends {Contract<ContractAbi, ContractEvent>}\n */\nexport class Deployable<\n  Payload,\n  ContractAbi extends Abi,\n> extends Contract<ContractAbi> {\n  /**\n   * The deployable payload used either for contract construction or initialization\n   *\n   * @protected\n   * @type {(Payload | undefined)}\n   */\n  protected _payload: Payload | undefined;\n  /**\n   * If it exists, [Viem Local Account](https://viem.sh/docs/accounts/local), if in a Node environment\n   *\n   * @protected\n   * @type {?Account}\n   */\n  protected _account?: Account;\n\n  /**\n   * Creates an instance of Deployable.\n   *\n   * @constructor\n   * @param {DeployableOptions} param0\n   * @param {?Account} [param0.account]\n   * @param {Config} param0.config\n   * @param {DeployablePayloadOrAddress<Payload>} payload\n   */\n  constructor(\n    { account, config }: DeployableOptions,\n    payload?: DeployablePayloadOrAddress<Payload>,\n  ) {\n    if (typeof payload === 'string') {\n      super(config, payload as Address);\n    } else {\n      super(config, undefined);\n      this._payload = payload as Payload;\n    }\n    if (account) this._account = account;\n  }\n\n  /**\n   * Returns the attached deployable payload, if it exists\n   *\n   * @readonly\n   * @type {Payload}\n   */\n  get payload() {\n    return this._payload;\n  }\n\n  /**\n   * Attaches a new payload for use with this deployable's initialization\n   *\n   * @public\n   * @param {Payload} payload\n   * @returns {this}\n   */\n  public withPayload(payload: Payload) {\n    this._payload = payload;\n    return this;\n  }\n\n  /**\n   * High level deployment function to deploy and await the contract address.\n   * This is mainly a convenience method to easily deploy a contract, but will not initialize a `Cloneable`,\n   * which makes it useless for Boost components.\n   * Obviously you can ignore the TS warnings and use this, but you shouldn't in most all cases.\n   *\n   * @public\n   * @async\n   * @param {?Payload} [_payload]\n   * @param {?DeployableOptions} [_options]\n   * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams] - See [viem.WaitForTransactionReceipt](https://v1.viem.sh/docs/actions/public/waitForTransactionReceipt.html#waitfortransactionreceipt)\n   * @returns {unknown}\n   */\n  protected async deploy(\n    _payload?: Payload,\n    _options?: DeployableOptions,\n    waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,\n  ) {\n    const config = _options?.config || this._config;\n    const address = await getDeployedContractAddress(\n      config,\n      this.deployRaw(_payload, _options),\n      waitParams,\n    );\n    this._address = address;\n    return this;\n  }\n\n  /**\n   * The lower level contract deployment function that does not await for the transaction receipt.\n   * This is mainly a convenience method to easily deploy a contract, but will not initialize a `Cloneable`,\n   * which makes it useless for Boost components.\n   * Obviously you can ignore the TS warnings and use this, but you shouldn't in most all cases.\n   *\n   * @public\n   * @async\n   * @param {?Payload} [_payload]\n   * @param {?DeployableOptions} [_options]\n   * @returns {Promise<Hash>}\n   * @throws {@link DeployableAlreadyDeployedError}\n   * @throws {@link DeployableWagmiConfigurationRequiredError}\n   * @throws {@link DeployableMissingPayloadError}\n   */\n  protected async deployRaw(\n    _payload?: Payload,\n    _options?: DeployableOptions,\n  ): Promise<Hash> {\n    if (this.address) throw new DeployableAlreadyDeployedError(this.address);\n    const [payload, options] = this.validateDeploymentConfig(\n      _payload,\n      _options,\n    );\n    return await deployContract(options.config, {\n      ...this.buildParameters(payload),\n      ...this.optionallyAttachAccount(options.account),\n    });\n  }\n\n  /**\n   * Internal function to attach the connected account to write methods to avoid manually passing in an account each call.\n   *\n   * @protected\n   * @param {?Account} [account]\n   * @returns {({ account: Account; } | { account?: undefined; })}\n   */\n  protected optionallyAttachAccount(account?: Account) {\n    if (account) return { account };\n    return this._account ? { account: this._account } : {};\n  }\n\n  /**\n   * Base parameter constructor, should return a partial `viem.deployContract` parameters shape including abi, bytecode, and arguments, if any.\n   * Expected to be overridden by protocol contracts.\n   *\n   * @public\n   * @param {?Payload} [_payload]\n   * @param {?DeployableOptions} [_options]\n   * @returns {GenericDeployableParams}\n   */\n  public buildParameters(\n    _payload?: Payload,\n    _options?: DeployableOptions,\n  ): GenericDeployableParams {\n    throw new DeployableBuildParametersUnspecifiedError();\n  }\n\n  /**\n   * Internal method used to ensure that a Wagmi configuration and payload are always present when deploying.\n   *\n   * @protected\n   * @template [P=Payload]\n   * @param {?P} [_payload]\n   * @param {?DeployableOptions} [_options]\n   * @returns {[P, DeployableOptions]}\n   * @throws {@link DeployableWagmiConfigurationRequiredError}\n   * @throws {@link DeployableMissingPayloadError}\n   */\n  protected validateDeploymentConfig<P = Payload>(\n    _payload?: P,\n    _options?: DeployableOptions,\n  ) {\n    const options = _options || {\n      config: this._config,\n      account: this._account,\n    };\n    if (!options) throw new DeployableWagmiConfigurationRequiredError();\n    const payload = _payload || this._payload;\n    return [payload, options] as [P, DeployableOptions];\n  }\n}\n"],"names":["Deployable","Contract","account","config","payload","_payload","_options","waitParams","address","getDeployedContractAddress","DeployableAlreadyDeployedError","options","deployContract","DeployableBuildParametersUnspecifiedError","DeployableWagmiConfigurationRequiredError"],"mappings":"gMA6EO,MAAMA,UAGHC,EAAAA,QAAsB,CAyB9B,YACE,CAAE,QAAAC,EAAS,OAAAC,CAAA,EACXC,EACA,CACI,OAAOA,GAAY,SACrB,MAAMD,EAAQC,CAAkB,GAEhC,MAAMD,EAAQ,MAAS,EACvB,KAAK,SAAWC,GAEdF,IAAS,KAAK,SAAWA,EAC/B,CAQA,IAAI,SAAU,CACZ,OAAO,KAAK,QACd,CASO,YAAYE,EAAkB,CACnC,YAAK,SAAWA,EACT,IACT,CAeA,MAAgB,OACdC,EACAC,EACAC,EACA,CACM,MAAAJ,GAASG,GAAA,YAAAA,EAAU,SAAU,KAAK,QAClCE,EAAU,MAAMC,EAAA,2BACpBN,EACA,KAAK,UAAUE,EAAUC,CAAQ,EACjCC,CAAA,EAEF,YAAK,SAAWC,EACT,IACT,CAiBA,MAAgB,UACdH,EACAC,EACe,CACf,GAAI,KAAK,QAAe,MAAA,IAAII,EAA+B,+BAAA,KAAK,OAAO,EACvE,KAAM,CAACN,EAASO,CAAO,EAAI,KAAK,yBAC9BN,EACAC,CAAA,EAEK,OAAA,MAAMM,EAAAA,eAAeD,EAAQ,OAAQ,CAC1C,GAAG,KAAK,gBAAgBP,CAAO,EAC/B,GAAG,KAAK,wBAAwBO,EAAQ,OAAO,CAAA,CAChD,CACH,CASU,wBAAwBT,EAAmB,CAC/C,OAAAA,EAAgB,CAAE,QAAAA,CAAQ,EACvB,KAAK,SAAW,CAAE,QAAS,KAAK,UAAa,EACtD,CAWO,gBACLG,EACAC,EACyB,CACzB,MAAM,IAAIO,EAA0C,yCACtD,CAaU,yBACRR,EACAC,EACA,CACA,MAAMK,EAAUL,GAAY,CAC1B,OAAQ,KAAK,QACb,QAAS,KAAK,QAAA,EAEhB,GAAI,CAACK,EAAS,MAAM,IAAIG,EAA0C,0CAE3D,MAAA,CADST,GAAY,KAAK,SAChBM,CAAO,CAC1B,CACF"}

package/dist/Deployable/Deployable.d.ts

@@ -0,0 +1,161 @@
+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.
+     * This is mainly a convenience method to easily deploy a contract, but will not initialize a `Cloneable`,
+     * which makes it useless for Boost components.
+     * Obviously you can ignore the TS warnings and use this, but you shouldn't in most all cases.
+     *
+     * @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}
+     */
+    protected 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.
+     * This is mainly a convenience method to easily deploy a contract, but will not initialize a `Cloneable`,
+     * which makes it useless for Boost components.
+     * Obviously you can ignore the TS warnings and use this, but you shouldn't in most all cases.
+     *
+     * @public
+     * @async
+     * @param {?Payload} [_payload]
+     * @param {?DeployableOptions} [_options]
+     * @returns {Promise<Hash>}
+     * @throws {@link DeployableAlreadyDeployedError}
+     * @throws {@link DeployableWagmiConfigurationRequiredError}
+     * @throws {@link DeployableMissingPayloadError}
+     */
+    protected 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;;;;;;;;;;;;OAYG;cACa,MAAM,CACpB,QAAQ,CAAC,EAAE,OAAO,EAClB,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,UAAU,CAAC,EAAE,IAAI,CAAC,mCAAmC,EAAE,MAAM,CAAC;IAYhE;;;;;;;;;;;;;;OAcG;cACa,SAAS,CACvB,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"}