@boostxyz/sdk 0.0.0-alpha.2 → 0.0.0-alpha.21

package/src/AllowLists/SimpleDenyList.ts

@@ -0,0 +1,250 @@
+import {
+  readSimpleAllowListOwner,
+  readSimpleDenyListIsAllowed,
+  simpleDenyListAbi,
+  simulateSimpleDenyListSetDenied,
+  writeSimpleDenyListSetDenied,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/allowlists/SimpleDenyList.sol/SimpleDenyList.json';
+import { getAccount } from '@wagmi/core';
+import {
+  type Address,
+  type ContractEventName,
+  type Hex,
+  encodeAbiParameters,
+  zeroAddress,
+  zeroHash,
+} from 'viem';
+import { SimpleDenyList as SimpleDenyListBases } from '../../dist/deployments.json';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTargetWithRBAC } from '../Deployable/DeployableTargetWithRBAC';
+import { DeployableUnknownOwnerProvidedError } from '../errors';
+import {
+  type GenericLog,
+  type ReadParams,
+  RegistryType,
+  type WriteParams,
+} from '../utils';
+
+export { simpleDenyListAbi };
+
+/**
+ * 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.
+ *
+ * @export
+ * @typedef {SimpleDenyListLog}
+ * @template {ContractEventName<typeof simpleDenyListAbi>} [event=ContractEventName<
+ *     typeof simpleDenyListAbi
+ *   >]
+ */
+export type SimpleDenyListLog<
+  event extends ContractEventName<typeof simpleDenyListAbi> = ContractEventName<
+    typeof simpleDenyListAbi
+  >,
+> = GenericLog<typeof simpleDenyListAbi, event>;
+
+/**
+ * A simple implementation of an AllowList that implicitly allows all addresses except those explicitly added to the deny list
+ *
+ * @export
+ * @class SimpleDenyList
+ * @typedef {SimpleDenyList}
+ * @extends {DeployableTargetWithRBAC<SimpleDenyListPayload>}
+ */
+export class SimpleDenyList<
+  Payload = SimpleDenyListPayload,
+> extends DeployableTargetWithRBAC<
+  Payload | undefined,
+  typeof simpleDenyListAbi
+> {
+  public override readonly abi = simpleDenyListAbi;
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {Record<number, Address>}
+   */
+  public static override bases: Record<number, Address> = {
+    ...(SimpleDenyListBases as Record<number, Address>),
+  };
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @static
+   * @type {RegistryType}
+   */
+  public static override registryType: RegistryType = RegistryType.ALLOW_LIST;
+
+  /**
+   * Retrieves the owner
+   *
+   * @public
+   * @async
+   * @param {?ReadParams} [params]
+   * @returns {Promise<Address>} - The address of the owner
+   */
+  public async owner(
+    params?: ReadParams<typeof simpleDenyListAbi, 'owner'>,
+  ): Promise<Address> {
+    return await readSimpleAllowListOwner(this._config, {
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+      address: this.assertValidAddress(),
+      args: [],
+    });
+  }
+
+  /**
+   * Check if a user is authorized (i.e. not denied)
+   *
+   * @public
+   * @async
+   * @param {Address} address - The address of the user
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>} - True if the user is authorized
+   */
+  public async isAllowed(
+    address: Address,
+    params?: ReadParams<typeof simpleDenyListAbi, 'isAllowed'>,
+  ): Promise<boolean> {
+    return await readSimpleDenyListIsAllowed(this._config, {
+      address: this.assertValidAddress(),
+      args: [address, zeroHash],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
+  /**
+   * Set the denied status of a user. The length of the `users_` and `denied_` arrays must be the same. This function can only be called by the owner
+   *
+   * @public
+   * @async
+   * @param {Address[]} addresses - The list of users to update
+   * @param {boolean[]} allowed - The denied status of each user
+   * @param {?WriteParams} [params]
+   * @returns {Promise<void>}
+   */
+  public async setDenied(
+    addresses: Address[],
+    allowed: boolean[],
+    params?: WriteParams<typeof simpleDenyListAbi, 'setDenied'>,
+  ) {
+    return await this.awaitResult(
+      this.setDeniedRaw(addresses, allowed, params),
+    );
+  }
+
+  /**
+   * Set the denied status of a user. The length of the `users_` and `denied_` arrays must be the same. This function can only be called by the owner
+   *
+   * @public
+   * @async
+   * @param {Address[]} addresses - The list of users to update
+   * @param {boolean[]} allowed - The denied status of each user
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: void; }>}
+   */
+  public async setDeniedRaw(
+    addresses: Address[],
+    allowed: boolean[],
+    params?: WriteParams<typeof simpleDenyListAbi, 'setDenied'>,
+  ) {
+    const { request, result } = await simulateSimpleDenyListSetDenied(
+      this._config,
+      {
+        address: this.assertValidAddress(),
+        args: [addresses, allowed],
+        ...this.optionallyAttachAccount(),
+        // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+        ...(params as any),
+      },
+    );
+    const hash = await writeSimpleDenyListSetDenied(this._config, request);
+    return { hash, result };
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @param {?SimpleDenyListPayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: Payload,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [p, options] = this.validateDeploymentConfig(_payload, _options);
+    const payload = p as SimpleDenyListPayload;
+    if (!payload.owner || payload.owner === zeroAddress) {
+      const owner = options.account
+        ? options.account.address
+        : options.config
+          ? getAccount(options.config).address
+          : this._account?.address;
+      if (owner) {
+        payload.owner = owner;
+      } else {
+        throw new DeployableUnknownOwnerProvidedError();
+      }
+    }
+    return {
+      abi: simpleDenyListAbi,
+      bytecode: bytecode as Hex,
+      args: [prepareSimpleDenyListPayload(payload)],
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}
+
+/**
+ * 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/Auth.ts

@@ -0,0 +1,11 @@
+import { PassthroughAuth } from './PassthroughAuth';
+
+export { PassthroughAuth };
+
+/**
+ * A union type representing all valid protocol Auth implementations
+ *
+ * @export
+ * @typedef {Auth}
+ */
+export type Auth = PassthroughAuth;

package/src/Auth/PassthroughAuth.test.ts

@@ -0,0 +1,12 @@
+import { zeroAddress } from 'viem';
+import { describe, expect, test } from 'vitest';
+import { defaultOptions } from '@boostxyz/test/helpers';
+import { PassthroughAuth } from './PassthroughAuth';
+
+describe('PassthroughAuth', () => {
+  test('can successfully be deployed', async () => {
+    const auth = new PassthroughAuth(defaultOptions);
+    await auth.deploy();
+    expect(await auth.isAuthorized(zeroAddress)).toBe(true);
+  });
+});

package/src/Auth/PassthroughAuth.ts

@@ -0,0 +1,80 @@
+import {
+  passthroughAuthAbi,
+  readPassthroughAuthIsAuthorized,
+} from '@boostxyz/evm';
+import { bytecode } from '@boostxyz/evm/artifacts/contracts/auth/PassthroughAuth.sol/PassthroughAuth.json';
+import type { Address, ContractEventName, Hex } from 'viem';
+import {
+  Deployable,
+  type DeployableOptions,
+  type GenericDeployableParams,
+} from '../Deployable/Deployable';
+import { DeployableTarget } from '../Deployable/DeployableTarget';
+import type { GenericLog, ReadParams } from '../utils';
+
+export { passthroughAuthAbi };
+
+/**
+ * A generic `viem.Log` event with support for `PassthroughAuth` event types.
+ *
+ * @export
+ * @typedef {PassthroughAuthLog}
+ * @template {ContractEventName<
+ *     typeof passthroughAuthAbi
+ *   >} [event=ContractEventName<typeof passthroughAuthAbi>]
+ */
+export type PassthroughAuthLog<
+  event extends ContractEventName<
+    typeof passthroughAuthAbi
+  > = ContractEventName<typeof passthroughAuthAbi>,
+> = GenericLog<typeof passthroughAuthAbi, event>;
+
+/**
+ *  A simple implementation of a Validator that verifies a given signature and checks the recovered address against a set of authorized signers
+ *
+ * @export
+ * @class PassthroughAuth
+ * @typedef {PassthroughAuth}
+ * @extends {DeployableTarget<PassthroughAuthPayload>}
+ */
+export class PassthroughAuth extends Deployable<
+  // biome-ignore lint/suspicious/noExplicitAny: takes no parameters
+  any,
+  typeof passthroughAuthAbi
+> {
+  public override readonly abi = passthroughAuthAbi;
+
+  public async isAuthorized(
+    address: Address,
+    params?: ReadParams<typeof passthroughAuthAbi, 'isAuthorized'>,
+  ) {
+    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
+      ...(params as any),
+    });
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @public
+   * @param {?PassthroughAuthPayload} [_payload]
+   * @param {?DeployableOptions} [_options]
+   * @returns {GenericDeployableParams}
+   */
+  public override buildParameters(
+    _payload?: never,
+    _options?: DeployableOptions,
+  ): GenericDeployableParams {
+    const [_, options] = this.validateDeploymentConfig({}, _options);
+    return {
+      abi: passthroughAuthAbi,
+      bytecode: bytecode as Hex,
+      // biome-ignore lint/suspicious/noExplicitAny: <takes no payload>
+      args: [] as any,
+      ...this.optionallyAttachAccount(options.account),
+    };
+  }
+}

package/src/Boost.ts

@@ -0,0 +1,287 @@
+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';
+import type { Incentive } from './Incentives/Incentive';
+import type { Validator } from './Validators/Validator';
+
+/**
+ * Interface representing a `BoostLib.Boost` on-chain struct
+ *
+ * @export
+ * @interface RawBoost
+ * @typedef {RawBoost}
+ */
+export interface RawBoost {
+  action: Address;
+  validator: Address;
+  allowList: Address;
+  budget: Address;
+  incentives: readonly Address[];
+  protocolFee: bigint;
+  maxParticipants: bigint;
+  owner: Address;
+}
+
+/**
+ * Configuration used to instantiate a `Boost` instance.
+ *
+ * @export
+ * @interface BoostConfig
+ * @typedef {BoostConfig}
+ */
+export interface BoostConfig {
+  /**
+   *
+   * @type {bigint}
+   */
+  id: bigint;
+  /**
+   *
+   * @type {Budget}
+   */
+  budget: Budget;
+  /**
+   *
+   * @type {Action}
+   */
+  action: Action;
+  /**
+   *
+   * @type {Validator}
+   */
+  validator: Validator;
+  /**
+   *
+   * @type {AllowList}
+   */
+  allowList: AllowList;
+  /**
+   *
+   * @type {Array<Incentive>}
+   */
+  incentives: Array<Incentive>;
+  /**
+   *
+   * @type {?bigint}
+   */
+  protocolFee?: bigint;
+  /**
+   *
+   * @type {?bigint}
+   */
+  maxParticipants?: bigint;
+  /**
+   *
+   * @type {?Address}
+   */
+  owner?: Address;
+}
+
+/**
+ * A struct representing a single Boost. Typically you would not construct this directly, rather get an instance from `BoostCore.createBoost` or `BoostCore.getBoost`
+ *
+ * @export
+ * @class Boost
+ * @typedef {Boost}
+ */
+export class Boost {
+  /**
+   *
+   * @readonly
+   * @type {bigint}
+   */
+  readonly id: bigint;
+  /**
+   *
+   * @readonly
+   * @type {Budget}
+   */
+  readonly budget: Budget;
+  /**
+   *
+   * @readonly
+   * @type {Action}
+   */
+  readonly action: Action;
+  /**
+   *
+   * @readonly
+   * @type {Validator}
+   */
+  readonly validator: Validator;
+  /**
+   *
+   * @readonly
+   * @type {AllowList}
+   */
+  readonly allowList: AllowList;
+  /**
+   *
+   * @readonly
+   * @type {Array<Incentive>}
+   */
+  readonly incentives: Array<Incentive>;
+  /**
+   *
+   * @readonly
+   * @type {bigint}
+   */
+  readonly protocolFee: bigint;
+  /**
+   *
+   * @readonly
+   * @type {bigint}
+   */
+  readonly maxParticipants: bigint;
+  /**
+   *
+   * @readonly
+   * @type {Address}
+   */
+  readonly owner: Address;
+
+  /**
+   * Creates an instance of Boost.
+   *
+   * @constructor
+   * @param {BoostConfig} config
+   */
+  constructor(config: BoostConfig) {
+    this.id = config.id;
+    this.budget = config.budget;
+    this.action = config.action;
+    this.validator = config.validator;
+    this.allowList = config.allowList;
+    this.incentives = config.incentives;
+    this.protocolFee = config.protocolFee || 0n;
+    this.maxParticipants = config.maxParticipants || 0n;
+    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;
+  /**
+   * 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.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,
+  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; uint256 maxParticipants; address owner; }',
+        'struct Target { bool isBase; address instance; bytes parameters; }',
+      ]),
+      [
+        {
+          budget,
+          action,
+          validator,
+          allowList,
+          incentives,
+          protocolFee,
+          maxParticipants,
+          owner,
+        },
+      ],
+    ),
+  ) as Hex;
+}