@boostxyz/sdk 0.0.0-alpha.7 → 0.0.0-alpha.9

package/src/AllowLists/SimpleDenyList.ts

@@ -10,6 +10,7 @@ import {
   type Address,
   type ContractEventName,
   type Hex,
+  encodeAbiParameters,
   zeroAddress,
   zeroHash,
 } from 'viem';
@@ -23,13 +24,32 @@ import {
   type GenericLog,
   type ReadParams,
   RegistryType,
-  type SimpleDenyListPayload,
   type WriteParams,
-  prepareSimpleDenyListPayload,
 } from '../utils';
 
 export { simpleDenyListAbi };
-export type { SimpleDenyListPayload };
+
+/**
+ * Object representation of a {@link SimpleDenyList} initialization payload.
+ *
+ * @export
+ * @interface SimpleDenyListPayload
+ * @typedef {SimpleDenyListPayload}
+ */
+export interface SimpleDenyListPayload {
+  /**
+   * The allow list's owner
+   *
+   * @type {Address}
+   */
+  owner: Address;
+  /**
+   * List of denied addresses.
+   *
+   * @type {Address[]}
+   */
+  denied: Address[];
+}
 
 /**
  * A generic `viem.Log` event with support for `SimpleDenyList` event types.
@@ -114,7 +134,9 @@ export class SimpleDenyList extends DeployableTarget<
     allowed: boolean[],
     params?: WriteParams<typeof simpleDenyListAbi, 'setDenied'>,
   ) {
-    return this.awaitResult(this.setDeniedRaw(addresses, allowed, params));
+    return await this.awaitResult(
+      this.setDeniedRaw(addresses, allowed, params),
+    );
   }
 
   /**
@@ -146,111 +168,6 @@ export class SimpleDenyList extends DeployableTarget<
     return { hash, result };
   }
 
-  // /**
-  //  * 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 {ContractEventName<typeof simpleDenyListAbi>} event
-  //  * @template {ExtractAbiEvent<
-  //  *       typeof simpleDenyListAbi,
-  //  *       event
-  //  *     >} [abiEvent=ExtractAbiEvent<typeof simpleDenyListAbi, event>]
-  //  * @param {?Omit<
-  //  *       GetLogsParams<typeof simpleDenyListAbi, event, abiEvent, abiEvent[]>,
-  //  *       'event' | 'events'
-  //  *     > & {
-  //  *       eventName?: event;
-  //  *       eventNames?: event[];
-  //  *     }} [params]
-  //  * @returns {Promise<GetLogsReturnType<abiEvent, abiEvent[]>>}
-  //  */
-  // public async getLogs<
-  //   event extends ContractEventName<typeof simpleDenyListAbi>,
-  //   const abiEvent extends ExtractAbiEvent<
-  //     typeof simpleDenyListAbi,
-  //     event
-  //   > = ExtractAbiEvent<typeof simpleDenyListAbi, event>,
-  // >(
-  //   params?: Omit<
-  //     GetLogsParams<typeof simpleDenyListAbi, event, abiEvent, abiEvent[]>,
-  //     'event' | 'events'
-  //   > & {
-  //     eventName?: event;
-  //     eventNames?: event[];
-  //   },
-  // ): Promise<GetLogsReturnType<abiEvent, abiEvent[]>> {
-  //   return getLogs(this._config.getClient({ chainId: params?.chainId }), {
-  //     // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wag
-  //     ...(params as any),
-  //     ...(params?.eventName
-  //       ? {
-  //           event: getAbiItem({
-  //             abi: simpleDenyListAbi,
-  //             name: params.eventName,
-  //             // biome-ignore lint/suspicious/noExplicitAny: awkward abi intersection issue
-  //           } as any),
-  //         }
-  //       : {}),
-  //     ...(params?.eventNames
-  //       ? {
-  //           events: params.eventNames.map((name) =>
-  //             getAbiItem({
-  //               abi: simpleDenyListAbi,
-  //               name,
-  //               // biome-ignore lint/suspicious/noExplicitAny: awkward abi intersection issue
-  //             } as any),
-  //           ),
-  //         }
-  //       : {}),
-  //     address: this.assertValidAddress(),
-  //   });
-  // }
-
-  // /**
-  //  * A typed wrapper for `wagmi.watchContractEvent`
-  //  *
-  //  * @public
-  //  * @async
-  //  * @template {ContractEventName<typeof simpleDenyListAbi>} event
-  //  * @param {(log: SimpleDenyListLog<event>) => unknown} cb
-  //  * @param {?WatchParams<typeof simpleDenyListAbi, event> & {
-  //  *       eventName?: event;
-  //  *     }} [params]
-  //  * @returns {unknown, params?: any) => unknown} Unsubscribe function
-  //  */
-  // public async subscribe<
-  //   event extends ContractEventName<typeof simpleDenyListAbi>,
-  // >(
-  //   cb: (log: SimpleDenyListLog<event>) => unknown,
-  //   params?: WatchParams<typeof simpleDenyListAbi, event> & {
-  //     eventName?: event;
-  //   },
-  // ) {
-  //   return watchContractEvent<
-  //     typeof this._config,
-  //     (typeof this._config)['chains'][number]['id'],
-  //     typeof simpleDenyListAbi,
-  //     event
-  //   >(this._config, {
-  //     // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
-  //     ...(params as any),
-  //     eventName: params?.eventName,
-  //     abi: simpleDenyListAbi,
-  //     address: this.assertValidAddress(),
-  //     onLogs: (logs) => {
-  //       for (let l of logs) {
-  //         cb(l as unknown as SimpleDenyListLog<event>);
-  //       }
-  //     },
-  //   });
-  // }
-
   /**
    * @inheritdoc
    *
@@ -287,3 +204,24 @@ export class SimpleDenyList extends DeployableTarget<
     };
   }
 }
+
+/**
+ * Given a {@link SimpleDenyListPayload}, properly encode the initialization payload.
+ *
+ * @param {SimpleDenyListPayload} param0
+ * @param {Address} param0.owner - The allow list's owner
+ * @param {Address[]} param0.denied - List of denied addresses.
+ * @returns {Hex}
+ */
+export function prepareSimpleDenyListPayload({
+  owner,
+  denied,
+}: SimpleDenyListPayload) {
+  return encodeAbiParameters(
+    [
+      { type: 'address', name: 'owner' },
+      { type: 'address[]', name: 'denied' },
+    ],
+    [owner, denied],
+  );
+}

package/src/Auth/PassthroughAuth.ts

@@ -48,7 +48,7 @@ export class PassthroughAuth extends Deployable<
     address: Address,
     params?: ReadParams<typeof passthroughAuthAbi, 'isAuthorized'>,
   ) {
-    return readPassthroughAuthIsAuthorized(this._config, {
+    return await readPassthroughAuthIsAuthorized(this._config, {
       address: this.assertValidAddress(),
       args: [address],
       // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally

package/src/Boost.ts

@@ -1,4 +1,11 @@
-import { type Address, zeroAddress } from 'viem';
+import { LibZip } from 'solady';
+import {
+  type Address,
+  type Hex,
+  encodeAbiParameters,
+  parseAbiParameters,
+  zeroAddress,
+} from 'viem';
 import type { Action } from './Actions/Action';
 import type { AllowList } from './AllowLists/AllowList';
 import type { Budget } from './Budgets/Budget';
@@ -153,3 +160,131 @@ export class Boost {
     this.owner = config.owner || zeroAddress;
   }
 }
+
+/**
+ * Object representation of `BoostLib.Target` struct. Used for low level Boost creation operations.
+ * This is used to pass the base contract and its initialization parameters in an efficient manner
+ *
+ * @export
+ * @typedef {Target}
+ */
+export type Target = {
+  isBase: boolean;
+  instance: Address;
+  parameters: Hex;
+};
+
+/**
+ * Object representation of `BoostCore.InitPayload` struct.
+ *
+ * @export
+ * @interface BoostPayload
+ * @typedef {BoostPayload}
+ */
+export interface BoostPayload {
+  /**
+   * Address to valid budget.
+   *
+   * @type {Address}
+   */
+  budget: Address;
+  /**
+   * Target for existing action, or base with initialization payload.
+   *
+   * @type {Target}
+   */
+  action: Target;
+  /**
+   * Target for existing validator, or base with initialization payload.
+   *
+   * @type {Target}
+   */
+  validator: Target;
+  /**
+   * Target for existing allowList, or base with initialization payload.
+   *
+   * @type {Target}
+   */
+  allowList: Target;
+  /**
+   * Targets for new incentives, with initialization payloads.
+   *
+   * @type {Target[]}
+   */
+  incentives: Target[];
+  /**
+   * The base protocol fee (in bps)
+   *
+   * @type {?bigint}
+   */
+  protocolFee?: bigint;
+  /**
+   * The base referral fee (in bps)
+   *
+   * @type {?bigint}
+   */
+  referralFee?: bigint;
+  /**
+   * Optional maximum amount of participants in the Boost.
+   *
+   * @type {?bigint}
+   */
+  maxParticipants?: bigint;
+  /**
+   * The owner of the Boost.
+   *
+   * @type {Address}
+   */
+  owner: Address;
+}
+
+/**
+ * Given a valid {@link BoostPayload}, properly encode and compress the payload for use with `createBoost`
+ *
+ * @export
+ * @param {BoostPayload} param0
+ * @param {Address} param0.budget - Address to valid budget.
+ * @param {Target} param0.action - Target for existing action, or base with initialization payload.
+ * @param {Target} param0.validator - Target for existing validator, or base with initialization payload.
+ * @param {Target} param0.allowList - Target for existing allowList, or base with initialization payload.
+ * @param {Target[]} param0.incentives - Targets for new incentives, with initialization payloads.
+ * @param {bigint} [param0.protocolFee=0n] - The base protocol fee (in bps)
+ * @param {bigint} [param0.referralFee=0n] - The base referral fee (in bps)
+ * @param {bigint} [param0.maxParticipants=0n] - Optional maximum amount of participants in the Boost.
+ * @param {Address} param0.owner - The owner of the Boost.
+ * @returns {Hex}
+ */
+export function prepareBoostPayload({
+  budget,
+  action,
+  validator,
+  allowList,
+  incentives,
+  protocolFee = 0n,
+  referralFee = 0n,
+  maxParticipants = 0n,
+  owner,
+}: BoostPayload): Hex {
+  return LibZip.cdCompress(
+    encodeAbiParameters(
+      parseAbiParameters([
+        'BoostPayload payload',
+        'struct BoostPayload { address budget; Target action; Target validator; Target allowList; Target[] incentives; uint64 protocolFee; uint64 referralFee; uint256 maxParticipants; address owner; }',
+        'struct Target { bool isBase; address instance; bytes parameters; }',
+      ]),
+      [
+        {
+          budget,
+          action,
+          validator,
+          allowList,
+          incentives,
+          protocolFee,
+          referralFee,
+          maxParticipants,
+          owner,
+        },
+      ],
+    ),
+  ) as Hex;
+}

package/src/BoostCore.test.ts

@@ -10,19 +10,12 @@ import {
   makeMockEventActionPayload,
 } from '../test/helpers';
 import { ContractAction } from './Actions/ContractAction';
-import { PassthroughAuth } from './Auth/PassthroughAuth';
 import { BoostCore } from './BoostCore';
 import type { ERC20Incentive } from './Incentives/ERC20Incentive';
+import { ERC1155StrategyType } from './Incentives/ERC1155Incentive';
+import { StrategyType } from './claiming';
 import { IncentiveNotCloneableError } from './errors';
-import {
-  ActionStep,
-  ERC1155StrategyType,
-  FilterType,
-  PrimitiveType,
-  SignatureType,
-  StrategyType,
-  bytes4,
-} from './utils';
+import { bytes4 } from './utils';
 
 let fixtures: Fixtures, budgets: BudgetFixtures;
 
@@ -683,7 +676,7 @@ describe('BoostCore', () => {
     expect(await client.claimFee()).toBe(100n);
   });
 
-  test('binds all actions, budgets, allowlists, incentives, and validators to reuse core options and account', async () => {
+  test('binds all actions, budgets, allowlists, incentives, and validators to reuse core options and account', () => {
     const { core } = fixtures;
 
     // const contractAction = core.ContractAction(zeroAddress);