@boostxyz/sdk 7.7.0 → 8.0.0-canary.0

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../src/utils.ts"],"sourcesContent":["import { events } from '@boostxyz/signatures';\nimport {\n  type Config,\n  type ReadContractParameters,\n  type SimulateContractParameters,\n  type WatchContractEventParameters,\n  getAccount,\n  getChainId,\n  readContract,\n  waitForTransactionReceipt,\n} from '@wagmi/core';\nimport type { ExtractAbiEvent } from 'abitype';\nimport type {\n  Abi,\n  AbiEvent,\n  Address,\n  ContractEventName,\n  ContractFunctionName,\n  GetLogsParameters,\n  Hash,\n  Hex,\n  Log,\n  WaitForTransactionReceiptParameters,\n} from 'viem';\nimport { isHex, keccak256, slice, toHex } from 'viem';\nimport {\n  InvalidProtocolChainIdError,\n  NoContractAddressUponReceiptError,\n} from './errors';\n\nexport type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;\n\n/**\n * Enum encapsulating all the different types of targets used in the Boost V2 Protocol.\n *\n * @export\n * @enum {number}\n */\nexport enum RegistryType {\n  ACTION = 0,\n  ALLOW_LIST = 1,\n  BUDGET = 2,\n  INCENTIVE = 3,\n  VALIDATOR = 4,\n}\n\n/**\n * Enum encapsulating all the different cheat codes for criteria modules.\n * An Event Action action step criteria with a `fieldIndex` set to `CheatCodes.ANY_ACTION_PARAM`, fieldType set to `PrimitiveType.BYTES`, and `filterType` set to `FilterType.EQUAL` will always return true when validating the field, regardless of inputs\n * An Event Action `ActionClaimant` with a `fieldIndex` set to `CheatCodes.TX_SENDER_CLAIMANT`, will always validate with the sender of a given transaction.\n *\n *\n * @export\n * @enum {number}\n */\nexport enum CheatCodes {\n  /* An Event Action action step criteria with a `fieldIndex` set to `CheatCodes.ANY_ACTION_PARAM`, fieldType set to `PrimitiveType.BYTES`, and `filterType` set to `FilterType.EQUAL` will always return true when validating the field, regardless of inputs */\n  ANY_ACTION_PARAM = 255,\n  /* An Event Action `ActionClaimant` with a `fieldIndex` set to `CheatCodes.TX_SENDER_CLAIMANT`, will always validate with the sender of a given transaction. */\n  TX_SENDER_CLAIMANT = 255,\n  /* For use with `ERC20VariableCriteriaIncentiveV2`, if the criteria's `fieldIndex` is set to `CheatCodes.GAS_REBATE_INCENTIVE`, will claim an incentive amount equal to the transaction's gas used. */\n  GAS_REBATE_INCENTIVE = 255,\n}\n\n/**\n * The signature for the Transfer event for both ERC20 and ERC721.\n *\n * @type {Hex}\n */\nexport const TRANSFER_SIGNATURE = events.selectors[\n  'Transfer(address indexed,address indexed,uint256 indexed)'\n] as Hex;\n\n/**\n * Helper type that encapsulates common writeContract parameters without fields like `abi`, `args`, `functionName`, `address` that are expected to be provided the SDK.\n * See (writeContract)[https://viem.sh/docs/contract/writeContract]\n *\n * @export\n * @typedef {WriteParams}\n * @template {Abi} abi\n * @template {ContractFunctionName<abi>} functionName\n */\nexport type WriteParams = Partial<\n  Omit<SimulateContractParameters, 'address' | 'args' | 'functionName' | 'abi'>\n>;\n\n/**\n * Helper type that encapsulates common readContract parameters without fields like `abi`, `args`, `functionName`, `address` that are expected to be provided the SDK.\n * See (readContract)[https://viem.sh/docs/contract/readContract]\n *\n * @export\n * @typedef {ReadParams}\n * @template {Abi} abi\n * @template {ContractFunctionName<abi>} functionName\n */\nexport type ReadParams = Partial<\n  Omit<ReadContractParameters, 'address' | 'args' | 'functionName' | 'abi'>\n>;\n\n/**\n * Helper type that encapsulates common `watchContractEvent` parameters without fields like `address`, and `abi` that are expected to be provided the SDK.\n * See (watchContractEvent)[https://wagmi.sh/core/api/actions/watchContractEvent]\n *\n * @export\n * @typedef {WatchParams}\n * @template {Abi} abi\n * @template {ContractEventName<abi> | undefined} [eventName=undefined]\n */\nexport type WatchParams<\n  abi extends Abi,\n  eventName extends ContractEventName<abi> | undefined = undefined,\n> = Partial<\n  Omit<WatchContractEventParameters<abi, eventName>, 'address' | 'abi'>\n>;\n\n/**\n * Helper type that encapsulates common `getLogs` parameters without fields like `address` that are expected to be provided the SDK.\n * See (getLogs)[https://viem.sh/docs/actions/public/getLogs#getlogs]\n *\n * @export\n * @typedef {GetLogsParams}\n * @template {Abi} abi\n * @template {ContractEventName<abi>} event\n * @template {ExtractAbiEvent<abi, event>} [abiEvent=ExtractAbiEvent<abi, event>]\n * @template {| readonly AbiEvent[]\n *     | readonly unknown[]\n *     | undefined} [abiEvents=abiEvent extends AbiEvent ? [abiEvent] : undefined]\n */\nexport type GetLogsParams<\n  abi extends Abi,\n  event extends ContractEventName<abi>,\n  abiEvent extends ExtractAbiEvent<abi, event> = ExtractAbiEvent<abi, event>,\n  abiEvents extends\n    | readonly AbiEvent[]\n    | readonly unknown[]\n    | undefined = abiEvent extends AbiEvent ? [abiEvent] : undefined,\n> = Partial<Omit<GetLogsParameters<abiEvent, abiEvents>, 'address'>> & {\n  chainId?: number | undefined;\n};\n\n/**\n * A generic `viem.Log` event with typed `args` support via a given `Abi` and `ContractEventName`\n *\n * @export\n * @typedef {GenericLog}\n * @template {Abi} abi\n * @template {ContractEventName<abi>} [event=ContractEventName<abi>]\n */\nexport type GenericLog<\n  abi extends Abi,\n  event extends ContractEventName<abi> = ContractEventName<abi>,\n> = Log<bigint, number, false, ExtractAbiEvent<abi, event>, false>;\n\n/**\n * Helper utility to convert a string to a `bytes4` type\n *\n * @export\n * @param {string} input\n * @returns {Hex}\n */\nexport function bytes4(input: string) {\n  return slice(isHex(input) ? keccak256(input) : keccak256(toHex(input)), 0, 4);\n}\n\n/**\n * Utility function to wait for a transaction receipt, and extract the contractAddress\n *\n * @export\n * @async\n * @param {WagmiConfig} config - [Wagmi Configuration](https://wagmi.sh/core/api/createConfig)\n * @param {Promise<Hash>} hash - A transaction hash promise\n * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams] - @see {@link WaitForTransactionReceiptParameters}\n * @returns {Promise<Address>}\n * @throws {@link NoContractAddressUponReceiptError} if no `contractAddress` exists after the transaction has been received\n */\nexport async function getDeployedContractAddress(\n  config: Config,\n  hash: Promise<Hash>,\n  waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,\n) {\n  const receipt = await waitForTransactionReceipt(config, {\n    ...waitParams,\n    hash: await hash,\n  });\n  if (!receipt.contractAddress)\n    throw new NoContractAddressUponReceiptError(receipt);\n  return receipt.contractAddress;\n}\n\n/**\n * Utility type to encapsulate a transaction hash, and the simulated result prior to submitting the transaction.\n *\n * @export\n * @typedef {HashAndSimulatedResult}\n * @template [T=unknown]\n */\nexport type HashAndSimulatedResult<T = unknown> = { hash: Hash; result: T };\n\n/**\n * Helper function to wait for a transaction receipt given a hash promise.\n *\n * @export\n * @async\n * @template [Result=unknown]\n * @param {WagmiConfig} config\n * @param {Promise<HashAndSimulatedResult<Result>>} hashPromise\n * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams]\n * @returns {Promise<Result>}\n */\nexport async function awaitResult<Result = unknown>(\n  config: Config,\n  hashPromise: Promise<HashAndSimulatedResult<Result>>,\n  waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,\n): Promise<Result> {\n  const { hash, result } = await hashPromise;\n  await waitForTransactionReceipt(config, {\n    ...waitParams,\n    hash,\n  });\n  return result;\n}\n\n/**\n * Given a wagmi config and a map of chain id's to addresses, determine an address/chainId combo that maps to the currently connected chain id, or throw a typed error.\n *\n * @export\n * @param {Config} config\n * @param {Record<string, Address>} addressByChainId\n * @param {number} desiredChainId\n * @returns {{ chainId: number, address: Address }}\n * @throws {@link InvalidProtocolChainIdError}\n */\nexport function assertValidAddressByChainId(\n  config: Config,\n  addressByChainId: Record<number, Address>,\n  desiredChainId?: number,\n): { chainId: number; address: Address } {\n  let chainId: number | undefined = undefined;\n\n  const wagmiChainId = getChainId(config);\n  if (wagmiChainId && addressByChainId[wagmiChainId]) chainId = wagmiChainId;\n  // if manually providing a chain id for some contract operation, try to use it\n  if (desiredChainId !== undefined) {\n    if (addressByChainId[desiredChainId]) chainId = desiredChainId;\n  } else if (wagmiChainId !== undefined) {\n    // otherwise if we can get the current chain id off the connected account and it matches one of ours, use it\n    if (addressByChainId[wagmiChainId]) chainId = wagmiChainId;\n  }\n  // chainId is still undefined, try to get chain id off viem client\n  if (chainId === undefined) {\n    const wagmiAccount = getAccount(config);\n    if (wagmiAccount.chainId !== undefined) {\n      // otherwise if we can get the current chain id off the connected account and it matches one of ours, use it\n      if (addressByChainId[wagmiAccount.chainId])\n        chainId = wagmiAccount.chainId;\n    }\n  }\n  // if chainId is STILL undefined, use our default addresses\n  // TODO: update this when on prod network\n  if (chainId === undefined) chainId = Number(__DEFAULT_CHAIN_ID__);\n  if (!addressByChainId[chainId])\n    throw new InvalidProtocolChainIdError(\n      chainId,\n      Object.keys(addressByChainId).map(Number),\n    );\n  // biome-ignore lint/style/noNonNullAssertion: this type should be narrowed by the above statement but isn't?\n  return { chainId, address: addressByChainId[chainId]! };\n}\n\n/**\n * Check an ERC20's balance for a given asset and\n *\n * @public\n * @async\n * @param {Config} [config]\n * @param {Address} [asset]\n * @param {Address} [owner]\n * @param {?ReadParams} [params]\n * @returns {Promise<bigint>} - The erc20 balance\n */\nexport async function getErc20Balance(\n  config: Config,\n  asset: Address,\n  owner: Address,\n  params?: ReadParams,\n) {\n  return await readContract(config, {\n    ...params,\n    functionName: 'balanceOf',\n    address: asset,\n    args: [owner],\n    abi: [\n      {\n        constant: true,\n        inputs: [\n          {\n            name: '_owner',\n            type: 'address',\n          },\n        ],\n        name: 'balanceOf',\n        outputs: [\n          {\n            name: 'balance',\n            type: 'uint256',\n          },\n        ],\n        stateMutability: 'view',\n        type: 'function',\n      },\n    ],\n  });\n}\n"],"names":["RegistryType","CheatCodes","TRANSFER_SIGNATURE","events","bytes4","input","slice","isHex","keccak256","toHex","getDeployedContractAddress","config","hash","waitParams","receipt","waitForTransactionReceipt","NoContractAddressUponReceiptError","awaitResult","hashPromise","result","assertValidAddressByChainId","addressByChainId","desiredChainId","chainId","wagmiChainId","getChainId","wagmiAccount","getAccount","InvalidProtocolChainIdError","getErc20Balance","asset","owner","params","readContract"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCY,IAAAA,sBAAAA,OACVA,EAAAA,EAAA,SAAS,CAAT,IAAA,UACAA,EAAAA,EAAA,aAAa,CAAb,IAAA,cACAA,EAAAA,EAAA,SAAS,CAAT,IAAA,UACAA,EAAAA,EAAA,YAAY,CAAZ,IAAA,aACAA,EAAAA,EAAA,YAAY,CAAZ,IAAA,aALUA,IAAAA,KAAA,CAAA,CAAA,GAiBAC,sBAAAA,OAEVA,EAAAA,EAAA,mBAAmB,GAAnB,IAAA,oBAEAA,EAAAA,EAAA,qBAAqB,GAArB,IAAA,sBAEAA,EAAAA,EAAA,uBAAuB,GAAvB,IAAA,wBANUA,IAAAA,KAAA,CAAA,CAAA;AAcC,MAAAC,IAAqBC,EAAO,UACvC,2DACF;AAyFO,SAASC,EAAOC,GAAe;AACpC,SAAOC,EAAMC,EAAMF,CAAK,IAAIG,EAAUH,CAAK,IAAIG,EAAUC,EAAMJ,CAAK,CAAC,GAAG,GAAG,CAAC;AAC9E;AAasB,eAAAK,EACpBC,GACAC,GACAC,GACA;AACM,QAAAC,IAAU,MAAMC,EAA0BJ,GAAQ;AAAA,IACtD,GAAGE;AAAA,IACH,MAAM,MAAMD;AAAA,EAAA,CACb;AACD,MAAI,CAACE,EAAQ;AACL,UAAA,IAAIE,EAAkCF,CAAO;AACrD,SAAOA,EAAQ;AACjB;AAsBsB,eAAAG,EACpBN,GACAO,GACAL,GACiB;AACjB,QAAM,EAAE,MAAAD,GAAM,QAAAO,EAAO,IAAI,MAAMD;AAC/B,eAAMH,EAA0BJ,GAAQ;AAAA,IACtC,GAAGE;AAAA,IACH,MAAAD;AAAA,EAAA,CACD,GACMO;AACT;AAYgB,SAAAC,EACdT,GACAU,GACAC,GACuC;AACvC,MAAIC;AAEE,QAAAC,IAAeC,EAAWd,CAAM;AAUtC,MATIa,KAAgBH,EAAiBG,CAAY,MAAaD,IAAAC,IAE1DF,MAAmB,SACjBD,EAAiBC,CAAc,MAAaC,IAAAD,KACvCE,MAAiB,UAEtBH,EAAiBG,CAAY,MAAaD,IAAAC,IAG5CD,MAAY,QAAW;AACnB,UAAAG,IAAeC,EAAWhB,CAAM;AAClC,IAAAe,EAAa,YAAY,UAEvBL,EAAiBK,EAAa,OAAO,MACvCH,IAAUG,EAAa;AAAA,EAE7B;AAII,MADAH,MAAY,WAAqBA,IAAO,WACxC,CAACF,EAAiBE,CAAO;AAC3B,UAAM,IAAIK;AAAA,MACRL;AAAA,MACA,OAAO,KAAKF,CAAgB,EAAE,IAAI,MAAM;AAAA,IAAA;AAG5C,SAAO,EAAE,SAAAE,GAAS,SAASF,EAAiBE,CAAO,EAAG;AACxD;AAaA,eAAsBM,EACpBlB,GACAmB,GACAC,GACAC,GACA;AACO,SAAA,MAAMC,EAAatB,GAAQ;AAAA,IAChC,GAAGqB;AAAA,IACH,cAAc;AAAA,IACd,SAASF;AAAA,IACT,MAAM,CAACC,CAAK;AAAA,IACZ,KAAK;AAAA,MACH;AAAA,QACE,UAAU;AAAA,QACV,QAAQ;AAAA,UACN;AAAA,YACE,MAAM;AAAA,YACN,MAAM;AAAA,UACR;AAAA,QACF;AAAA,QACA,MAAM;AAAA,QACN,SAAS;AAAA,UACP;AAAA,YACE,MAAM;AAAA,YACN,MAAM;AAAA,UACR;AAAA,QACF;AAAA,QACA,iBAAiB;AAAA,QACjB,MAAM;AAAA,MACR;AAAA,IACF;AAAA,EAAA,CACD;AACH;"}
+{"version":3,"file":"utils.js","sources":["../src/utils.ts"],"sourcesContent":["import { events } from '@boostxyz/signatures';\nimport {\n  type Config,\n  type ReadContractParameters,\n  type SimulateContractParameters,\n  type WatchContractEventParameters,\n  getAccount,\n  getChainId,\n  readContract,\n  waitForTransactionReceipt,\n} from '@wagmi/core';\nimport type { ExtractAbiEvent } from 'abitype';\nimport type {\n  Abi,\n  AbiEvent,\n  Address,\n  ContractEventName,\n  GetLogsParameters,\n  Hash,\n  Hex,\n  Log,\n  WaitForTransactionReceiptParameters,\n} from 'viem';\nimport { isHex, keccak256, slice, toHex } from 'viem';\nimport {\n  InvalidProtocolChainIdError,\n  NoContractAddressUponReceiptError,\n} from './errors';\n\nexport type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;\n\n/**\n * Enum encapsulating all the different types of targets used in the Boost V2 Protocol.\n *\n * @export\n * @enum {number}\n */\nexport enum RegistryType {\n  ACTION = 0,\n  ALLOW_LIST = 1,\n  BUDGET = 2,\n  INCENTIVE = 3,\n  VALIDATOR = 4,\n}\n\n/**\n * Enum encapsulating all the different cheat codes for criteria modules.\n * An Event Action action step criteria with a `fieldIndex` set to `CheatCodes.ANY_ACTION_PARAM`, fieldType set to `PrimitiveType.BYTES`, and `filterType` set to `FilterType.EQUAL` will always return true when validating the field, regardless of inputs\n * An Event Action `ActionClaimant` with a `fieldIndex` set to `CheatCodes.TX_SENDER_CLAIMANT`, will always validate with the sender of a given transaction.\n *\n *\n * @export\n * @enum {number}\n */\nexport enum CheatCodes {\n  /* An Event Action action step criteria with a `fieldIndex` set to `CheatCodes.ANY_ACTION_PARAM`, fieldType set to `PrimitiveType.BYTES`, and `filterType` set to `FilterType.EQUAL` will always return true when validating the field, regardless of inputs */\n  ANY_ACTION_PARAM = 255,\n  /* An Event Action `ActionClaimant` with a `fieldIndex` set to `CheatCodes.TX_SENDER_CLAIMANT`, will always validate with the sender of a given transaction. */\n  TX_SENDER_CLAIMANT = 255,\n  /* For use with `ERC20VariableCriteriaIncentiveV2`, if the criteria's `fieldIndex` is set to `CheatCodes.GAS_REBATE_INCENTIVE`, will claim an incentive amount equal to the transaction's gas used. */\n  GAS_REBATE_INCENTIVE = 255,\n}\n\n/**\n * The signature for the Transfer event for both ERC20 and ERC721.\n *\n * @type {Hex}\n */\nexport const TRANSFER_SIGNATURE = events.selectors[\n  'Transfer(address indexed,address indexed,uint256 indexed)'\n] as Hex;\n\n/**\n * Helper type that encapsulates common writeContract parameters without fields like `abi`, `args`, `functionName`, `address` that are expected to be provided the SDK.\n * See (writeContract)[https://viem.sh/docs/contract/writeContract]\n *\n * @export\n * @typedef {WriteParams}\n * @template {Abi} abi\n * @template {ContractFunctionName<abi>} functionName\n */\nexport type WriteParams = Partial<\n  Omit<SimulateContractParameters, 'address' | 'args' | 'functionName' | 'abi'>\n>;\n\n/**\n * Helper type that encapsulates common readContract parameters without fields like `abi`, `args`, `functionName`, `address` that are expected to be provided the SDK.\n * See (readContract)[https://viem.sh/docs/contract/readContract]\n *\n * @export\n * @typedef {ReadParams}\n * @template {Abi} abi\n * @template {ContractFunctionName<abi>} functionName\n */\nexport type ReadParams = Partial<\n  Omit<ReadContractParameters, 'address' | 'args' | 'functionName' | 'abi'>\n>;\n\n/**\n * Helper type that encapsulates common `watchContractEvent` parameters without fields like `address`, and `abi` that are expected to be provided the SDK.\n * See (watchContractEvent)[https://wagmi.sh/core/api/actions/watchContractEvent]\n *\n * @export\n * @typedef {WatchParams}\n * @template {Abi} abi\n * @template {ContractEventName<abi> | undefined} [eventName=undefined]\n */\nexport type WatchParams<\n  abi extends Abi,\n  eventName extends ContractEventName<abi> | undefined = undefined,\n> = Partial<\n  Omit<WatchContractEventParameters<abi, eventName>, 'address' | 'abi'>\n>;\n\n/**\n * Helper type that encapsulates common `getLogs` parameters without fields like `address` that are expected to be provided the SDK.\n * See (getLogs)[https://viem.sh/docs/actions/public/getLogs#getlogs]\n *\n * @export\n * @typedef {GetLogsParams}\n * @template {Abi} abi\n * @template {ContractEventName<abi>} event\n * @template {ExtractAbiEvent<abi, event>} [abiEvent=ExtractAbiEvent<abi, event>]\n * @template {| readonly AbiEvent[]\n *     | readonly unknown[]\n *     | undefined} [abiEvents=abiEvent extends AbiEvent ? [abiEvent] : undefined]\n */\nexport type GetLogsParams<\n  abi extends Abi,\n  event extends ContractEventName<abi>,\n  abiEvent extends ExtractAbiEvent<abi, event> = ExtractAbiEvent<abi, event>,\n  abiEvents extends\n    | readonly AbiEvent[]\n    | readonly unknown[]\n    | undefined = abiEvent extends AbiEvent ? [abiEvent] : undefined,\n> = Partial<Omit<GetLogsParameters<abiEvent, abiEvents>, 'address'>> & {\n  chainId?: number | undefined;\n};\n\n/**\n * A generic `viem.Log` event with typed `args` support via a given `Abi` and `ContractEventName`\n *\n * @export\n * @typedef {GenericLog}\n * @template {Abi} abi\n * @template {ContractEventName<abi>} [event=ContractEventName<abi>]\n */\nexport type GenericLog<\n  abi extends Abi,\n  event extends ContractEventName<abi> = ContractEventName<abi>,\n> = Log<bigint, number, false, ExtractAbiEvent<abi, event>, false>;\n\n/**\n * Helper utility to convert a string to a `bytes4` type\n *\n * @export\n * @param {string} input\n * @returns {Hex}\n */\nexport function bytes4(input: string) {\n  return slice(isHex(input) ? keccak256(input) : keccak256(toHex(input)), 0, 4);\n}\n\n/**\n * Utility function to wait for a transaction receipt, and extract the contractAddress\n *\n * @export\n * @async\n * @param {WagmiConfig} config - [Wagmi Configuration](https://wagmi.sh/core/api/createConfig)\n * @param {Promise<Hash>} hash - A transaction hash promise\n * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams] - @see {@link WaitForTransactionReceiptParameters}\n * @returns {Promise<Address>}\n * @throws {@link NoContractAddressUponReceiptError} if no `contractAddress` exists after the transaction has been received\n */\nexport async function getDeployedContractAddress(\n  config: Config,\n  hash: Promise<Hash>,\n  waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,\n) {\n  const receipt = await waitForTransactionReceipt(config, {\n    ...waitParams,\n    hash: await hash,\n  });\n  if (!receipt.contractAddress)\n    throw new NoContractAddressUponReceiptError(receipt);\n  return receipt.contractAddress;\n}\n\n/**\n * Utility type to encapsulate a transaction hash, and the simulated result prior to submitting the transaction.\n *\n * @export\n * @typedef {HashAndSimulatedResult}\n * @template [T=unknown]\n */\nexport type HashAndSimulatedResult<T = unknown> = { hash: Hash; result: T };\n\n/**\n * Helper function to wait for a transaction receipt given a hash promise.\n *\n * @export\n * @async\n * @template [Result=unknown]\n * @param {WagmiConfig} config\n * @param {Promise<HashAndSimulatedResult<Result>>} hashPromise\n * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams]\n * @returns {Promise<Result>}\n */\nexport async function awaitResult<Result = unknown>(\n  config: Config,\n  hashPromise: Promise<HashAndSimulatedResult<Result>>,\n  waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,\n): Promise<Result> {\n  const { hash, result } = await hashPromise;\n  await waitForTransactionReceipt(config, {\n    ...waitParams,\n    hash,\n  });\n  return result;\n}\n\n/**\n * Given a wagmi config and a map of chain id's to addresses, determine an address/chainId combo that maps to the currently connected chain id, or throw a typed error.\n *\n * @export\n * @param {Config} config\n * @param {Record<string, Address>} addressByChainId\n * @param {number} desiredChainId\n * @returns {{ chainId: number, address: Address }}\n * @throws {@link InvalidProtocolChainIdError}\n */\nexport function assertValidAddressByChainId(\n  config: Config,\n  addressByChainId: Record<number, Address>,\n  desiredChainId?: number,\n): { chainId: number; address: Address } {\n  let chainId: number | undefined = undefined;\n\n  const wagmiChainId = getChainId(config);\n  if (wagmiChainId && addressByChainId[wagmiChainId]) chainId = wagmiChainId;\n  // if manually providing a chain id for some contract operation, try to use it\n  if (desiredChainId !== undefined) {\n    if (addressByChainId[desiredChainId]) chainId = desiredChainId;\n  } else if (wagmiChainId !== undefined) {\n    // otherwise if we can get the current chain id off the connected account and it matches one of ours, use it\n    if (addressByChainId[wagmiChainId]) chainId = wagmiChainId;\n  }\n  // chainId is still undefined, try to get chain id off viem client\n  if (chainId === undefined) {\n    const wagmiAccount = getAccount(config);\n    if (wagmiAccount.chainId !== undefined) {\n      // otherwise if we can get the current chain id off the connected account and it matches one of ours, use it\n      if (addressByChainId[wagmiAccount.chainId])\n        chainId = wagmiAccount.chainId;\n    }\n  }\n  // if chainId is STILL undefined, use our default addresses\n  // TODO: update this when on prod network\n  if (chainId === undefined) chainId = Number(__DEFAULT_CHAIN_ID__);\n  if (!addressByChainId[chainId])\n    throw new InvalidProtocolChainIdError(\n      chainId,\n      Object.keys(addressByChainId).map(Number),\n    );\n  // biome-ignore lint/style/noNonNullAssertion: this type should be narrowed by the above statement but isn't?\n  return { chainId, address: addressByChainId[chainId]! };\n}\n\n/**\n * Check an ERC20's balance for a given asset and\n *\n * @public\n * @async\n * @param {Config} [config]\n * @param {Address} [asset]\n * @param {Address} [owner]\n * @param {?ReadParams} [params]\n * @returns {Promise<bigint>} - The erc20 balance\n */\nexport async function getErc20Balance(\n  config: Config,\n  asset: Address,\n  owner: Address,\n  params?: ReadParams,\n) {\n  return await readContract(config, {\n    ...params,\n    functionName: 'balanceOf',\n    address: asset,\n    args: [owner],\n    abi: [\n      {\n        constant: true,\n        inputs: [\n          {\n            name: '_owner',\n            type: 'address',\n          },\n        ],\n        name: 'balanceOf',\n        outputs: [\n          {\n            name: 'balance',\n            type: 'uint256',\n          },\n        ],\n        stateMutability: 'view',\n        type: 'function',\n      },\n    ],\n  });\n}\n"],"names":["RegistryType","CheatCodes","TRANSFER_SIGNATURE","events","bytes4","input","slice","isHex","keccak256","toHex","getDeployedContractAddress","config","hash","waitParams","receipt","waitForTransactionReceipt","NoContractAddressUponReceiptError","awaitResult","hashPromise","result","assertValidAddressByChainId","addressByChainId","desiredChainId","chainId","wagmiChainId","getChainId","wagmiAccount","getAccount","InvalidProtocolChainIdError","getErc20Balance","asset","owner","params","readContract"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boostxyz/sdk",
-  "version": "7.7.0",
+  "version": "8.0.0-canary.0",
   "license": "GPL-3.0-or-later",
   "type": "module",
   "files": [

package/src/Actions/EventAction.test.ts

@@ -44,7 +44,9 @@ import {
   packCriteriaFieldIndexes,
   unpackCriteriaFieldIndexes,
   isCriteriaFieldIndexTuple,
-  decodeAndReorderLogArgs
+  packClaimantFieldIndexes,
+  decodeAndReorderLogArgs,
+  ActionClaimant
 } from "./EventAction";
 import { allKnownSignatures } from "@boostxyz/test/allKnownSignatures";
 import { getTransactionReceipt } from "@wagmi/core";
@@ -1602,3 +1604,161 @@ describe("criteria field index tuple support", () => {
     });
   });
 });
+
+describe("claimant tuple field support", () => {
+  describe("validateClaimantAgainstArgs with tuple access", () => {
+    test("correctly extracts address from tuple field", () => {
+      const eventAction = new EventAction({ config: {} as any });
+      
+      // Test args with a tuple containing an address at position [2][1]
+      const testArgs = [
+        "0x1111111111111111111111111111111111111111",
+        100n,
+        ["0x2222222222222222222222222222222222222222", "0x3333333333333333333333333333333333333333", 500n],
+        "test"
+      ];
+
+      // Test extracting from tuple at args[2][1]
+      const claimant: ActionClaimant = {
+        signatureType: SignatureType.EVENT,
+        signature: zeroHash,
+        fieldIndex: packClaimantFieldIndexes([2, 1]),
+        targetContract: zeroAddress,
+        chainid: 1
+      };
+
+      const result = eventAction.validateClaimantAgainstArgs(claimant, { args: testArgs });
+      expect(result).toBe("0x3333333333333333333333333333333333333333");
+    });
+
+    test("returns undefined if tuple index is out of bounds", () => {
+      const eventAction = new EventAction({ config: {} as any });
+      
+      const testArgs = [
+        "0x1111111111111111111111111111111111111111",
+        ["0x2222222222222222222222222222222222222222"]
+      ];
+
+      // Try to access args[1][2] which doesn't exist
+      const claimant: ActionClaimant = {
+        signatureType: SignatureType.EVENT,
+        signature: zeroHash,
+        fieldIndex: packClaimantFieldIndexes([1, 2]),
+        targetContract: zeroAddress,
+        chainid: 1
+      };
+
+      const result = eventAction.validateClaimantAgainstArgs(claimant, { args: testArgs });
+      expect(result).toBeUndefined();
+    });
+
+    test("returns undefined if first index is out of bounds", () => {
+      const eventAction = new EventAction({ config: {} as any });
+      
+      const testArgs = ["0x1111111111111111111111111111111111111111"];
+
+      // Try to access args[5][0] where args[5] doesn't exist
+      const claimant: ActionClaimant = {
+        signatureType: SignatureType.EVENT,
+        signature: zeroHash,
+        fieldIndex: packClaimantFieldIndexes([5, 0]),
+        targetContract: zeroAddress,
+        chainid: 1
+      };
+
+      const result = eventAction.validateClaimantAgainstArgs(claimant, { args: testArgs });
+      expect(result).toBeUndefined();
+    });
+
+    test("returns undefined if tuple field is not an address", () => {
+      const eventAction = new EventAction({ config: {} as any });
+      
+      const testArgs = [
+        ["not-an-address", 123n, "test"]
+      ];
+
+      // Try to access args[0][0] which is not an address
+      const claimant: ActionClaimant = {
+        signatureType: SignatureType.EVENT,
+        signature: zeroHash,
+        fieldIndex: packClaimantFieldIndexes([0, 0]),
+        targetContract: zeroAddress,
+        chainid: 1
+      };
+
+      const result = eventAction.validateClaimantAgainstArgs(claimant, { args: testArgs });
+      expect(result).toBeUndefined();
+    });
+
+    test("returns undefined if field at first index is not a tuple", () => {
+      const eventAction = new EventAction({ config: {} as any });
+      
+      const testArgs = [
+        "0x1111111111111111111111111111111111111111",
+        "not-a-tuple"
+      ];
+
+      // Try to access args[1][0] but args[1] is not an array
+      const claimant: ActionClaimant = {
+        signatureType: SignatureType.EVENT,
+        signature: zeroHash,
+        fieldIndex: packClaimantFieldIndexes([1, 0]),
+        targetContract: zeroAddress,
+        chainid: 1
+      };
+
+      const result = eventAction.validateClaimantAgainstArgs(claimant, { args: testArgs });
+      expect(result).toBeUndefined();
+    });
+
+    test("still handles direct field access correctly", () => {
+      const eventAction = new EventAction({ config: {} as any });
+      
+      const testArgs = [
+        "0x1111111111111111111111111111111111111111",
+        "0x2222222222222222222222222222222222222222",
+        100n
+      ];
+
+      // Direct access to args[1] (not a tuple index)
+      const claimant: ActionClaimant = {
+        signatureType: SignatureType.EVENT,
+        signature: zeroHash,
+        fieldIndex: 1,
+        targetContract: zeroAddress,
+        chainid: 1
+      };
+
+      const result = eventAction.validateClaimantAgainstArgs(claimant, { args: testArgs });
+      expect(result).toBe("0x2222222222222222222222222222222222222222");
+    });
+
+    test("handles complex tuple with correct address", () => {
+      const eventAction = new EventAction({ config: {} as any });
+      
+      // Complex nested structure
+      const testArgs = [
+        { someField: "data" },
+        100n,
+        [
+          "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+          ["nested", "data"],
+          "0xcccccccccccccccccccccccccccccccccccccccc"
+        ]
+      ];
+
+      // Access args[2][3] which is an address
+      const claimant: ActionClaimant = {
+        signatureType: SignatureType.EVENT,
+        signature: zeroHash,
+        fieldIndex: packClaimantFieldIndexes([2, 3]),
+        targetContract: zeroAddress,
+        chainid: 1
+      };
+
+      const result = eventAction.validateClaimantAgainstArgs(claimant, { args: testArgs });
+      expect(result).toBe("0xcccccccccccccccccccccccccccccccccccccccc");
+    });
+  });
+});

package/src/Actions/EventAction.ts

@@ -671,11 +671,28 @@ export class EventAction extends DeployableTarget<
       args: Array<unknown> | readonly unknown[] | Record<string, unknown>;
     },
   ): Address | undefined {
-    if (
-      !logOrFnData ||
-      !Array.isArray(logOrFnData?.args) ||
-      logOrFnData?.args.length <= claimant.fieldIndex
-    ) {
+    if (!logOrFnData || !Array.isArray(logOrFnData?.args)) {
+      return;
+    }
+
+    if (isClaimantFieldIndexTuple(claimant.fieldIndex)) {
+      const [index0, index1] = unpackClaimantFieldIndexes(claimant.fieldIndex);
+
+      if (logOrFnData.args.length <= index0) {
+        return;
+      }
+
+      const tuple = logOrFnData.args[index0];
+      if (!Array.isArray(tuple) || tuple.length <= index1) {
+        return;
+      }
+
+      const maybeAddress = tuple[index1];
+      if (isAddress(maybeAddress)) return maybeAddress;
+      return;
+    }
+
+    if (logOrFnData.args.length <= claimant.fieldIndex) {
       return;
     }
     const maybeAddress = logOrFnData.args.at(claimant.fieldIndex);
@@ -1990,6 +2007,36 @@ export function isCriteriaFieldIndexTuple(fieldIndex: number): boolean {
   return fieldIndex >= 32;
 }
 
+/**
+ * Helper function to check if a claimant fieldIndex represents tuple access.
+ *
+ * @param {number} fieldIndex - The field index to check
+ * @returns {boolean} - True if it's a tuple index, false for direct access
+ */
+export function isClaimantFieldIndexTuple(fieldIndex: number): boolean {
+  return isCriteriaFieldIndexTuple(fieldIndex);
+}
+
+/**
+ * Packs two indices for claimant tuple access.
+ *
+ * @param {[number, number]} indices - Tuple of [firstIndex, secondIndex]
+ * @returns {number} - Packed uint8 value for the claimant fieldIndex
+ */
+export function packClaimantFieldIndexes(indices: [number, number]): number {
+  return packCriteriaFieldIndexes(indices);
+}
+
+/**
+ * Unpacks a claimant fieldIndex into tuple indices.
+ *
+ * @param {number} packed - Packed fieldIndex value
+ * @returns {[number, number]} - [firstIndex, secondIndex]
+ */
+export function unpackClaimantFieldIndexes(packed: number): [number, number] {
+  return unpackCriteriaFieldIndexes(packed);
+}
+
 /**
  * Extracts a scalar value from a tuple within event or function arguments.
  * This is used for incentive criteria when determining reward amounts.

package/src/BoostCore.test.ts

@@ -77,6 +77,7 @@ describe("BoostCore", () => {
       await core.getBoost(1000n);
     } catch (e) {
       expect(e instanceof BoostNotFoundError).toBe(true);
+      // @ts-ignore
       expect(e.id).toBe("1000");
     }
   });
@@ -648,20 +649,20 @@ describe("BoostCore", () => {
     // expect(erc721MintAction._account).toEqual(defaultOptions.account);
 
     const eventAction = core.EventAction(zeroAddress);
-    expect(eventAction._config).toEqual(defaultOptions.config);
-    expect(eventAction._account).toEqual(defaultOptions.account);
+    expect(eventAction.config).toEqual(defaultOptions.config);
+    expect(eventAction.account).toEqual(defaultOptions.account);
 
     const allowList = core.SimpleAllowList(zeroAddress);
-    expect(allowList._config).toEqual(defaultOptions.config);
-    expect(allowList._account).toEqual(defaultOptions.account);
+    expect(allowList.config).toEqual(defaultOptions.config);
+    expect(allowList.account).toEqual(defaultOptions.account);
 
     const denyList = core.SimpleDenyList(zeroAddress);
-    expect(denyList._config).toEqual(defaultOptions.config);
-    expect(denyList._account).toEqual(defaultOptions.account);
+    expect(denyList.config).toEqual(defaultOptions.config);
+    expect(denyList.account).toEqual(defaultOptions.account);
 
     const managedBudget = core.ManagedBudget(zeroAddress);
-    expect(managedBudget._config).toEqual(defaultOptions.config);
-    expect(managedBudget._account).toEqual(defaultOptions.account);
+    expect(managedBudget.config).toEqual(defaultOptions.config);
+    expect(managedBudget.account).toEqual(defaultOptions.account);
 
     // const simpleBudget = core.SimpleBudget(zeroAddress);
     // expect(simpleBudget._config).toEqual(defaultOptions.config);
@@ -675,8 +676,8 @@ describe("BoostCore", () => {
       allowList: zeroAddress,
       limit: 0n,
     });
-    expect(allowListIncentive._config).toEqual(defaultOptions.config);
-    expect(allowListIncentive._account).toEqual(defaultOptions.account);
+    expect(allowListIncentive.config).toEqual(defaultOptions.config);
+    expect(allowListIncentive.account).toEqual(defaultOptions.account);
 
     const cgdaIncentive = core.CGDAIncentive({
       asset: zeroAddress,
@@ -686,8 +687,8 @@ describe("BoostCore", () => {
       totalBudget: 0n,
       manager: zeroAddress,
     });
-    expect(cgdaIncentive._config).toEqual(defaultOptions.config);
-    expect(cgdaIncentive._account).toEqual(defaultOptions.account);
+    expect(cgdaIncentive.config).toEqual(defaultOptions.config);
+    expect(cgdaIncentive.account).toEqual(defaultOptions.account);
 
     const erc20Incentive = core.ERC20Incentive({
       asset: zeroAddress,
@@ -695,16 +696,17 @@ describe("BoostCore", () => {
       reward: 0n,
       limit: 0n,
     });
-    expect(erc20Incentive._config).toEqual(defaultOptions.config);
-    expect(erc20Incentive._account).toEqual(defaultOptions.account);
+    expect(erc20Incentive.config).toEqual(defaultOptions.config);
+    expect(erc20Incentive.account).toEqual(defaultOptions.account);
 
     const erc20VariableIncentive = core.ERC20VariableIncentive({
       asset: zeroAddress,
       reward: 0n,
       limit: 0n,
+      manager: zeroAddress,
     });
-    expect(erc20VariableIncentive._config).toEqual(defaultOptions.config);
-    expect(erc20VariableIncentive._account).toEqual(defaultOptions.account);
+    expect(erc20VariableIncentive.config).toEqual(defaultOptions.config);
+    expect(erc20VariableIncentive.account).toEqual(defaultOptions.account);
 
     // const erc1155Incentive = core.ERC1155Incentive({
     //   asset: zeroAddress,
@@ -722,12 +724,12 @@ describe("BoostCore", () => {
       reward: 0n,
       limit: 0n,
     });
-    expect(pointsIncentive._config).toEqual(defaultOptions.config);
-    expect(pointsIncentive._account).toEqual(defaultOptions.account);
+    expect(pointsIncentive.config).toEqual(defaultOptions.config);
+    expect(pointsIncentive.account).toEqual(defaultOptions.account);
 
     const signerValidator = core.SignerValidator(zeroAddress);
-    expect(signerValidator._config).toEqual(defaultOptions.config);
-    expect(signerValidator._account).toEqual(defaultOptions.account);
+    expect(signerValidator.config).toEqual(defaultOptions.config);
+    expect(signerValidator.account).toEqual(defaultOptions.account);
   });
 
   test("can subscribe to contract events", async () => {
@@ -776,6 +778,7 @@ describe("BoostCore", () => {
     const { core } = fixtures;
 
     const auth = core.PassthroughAuth();
+    // @ts-ignore
     await auth.deploy();
     await core.setCreateBoostAuth(auth);
     expect((await core.createBoostAuth()).toLowerCase()).toBe(
@@ -1032,6 +1035,8 @@ describe("Top-Up Incentives", () => {
   let boostId: bigint;
 
   beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
+    budgets = await loadFixture(fundBudget(defaultOptions, fixtures));
     const { core } = fixtures;
     const { budget, erc20 } = budgets;
 
@@ -1078,12 +1083,9 @@ describe("Top-Up Incentives", () => {
     const { core } = fixtures;
     const { budget, erc20 } = budgets;
 
-    console.log("budget", budget.assertValidAddress());
-
     const netTopup = parseEther("5");
 
     await core.topupIncentiveFromBudgetPreFee(boostId, 0n, netTopup, budget.assertValidAddress());
-    console.log("topup done");
 
     expect(await incentive.limit()).toBe(5n + 5n); // original limit 5 + topup 5
   });
@@ -1155,6 +1157,8 @@ describe("ERC20PeggedVariableCriteriaIncentive Top-Ups", () => {
   let erc721: MockERC721;
 
   beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
+    budgets = await loadFixture(fundBudget(defaultOptions, fixtures));
     const { core } = fixtures;
     const { budget, erc20 } = budgets;
 
@@ -1285,6 +1289,13 @@ describe("ERC20PeggedVariableCriteriaIncentive Top-Ups", () => {
 });
 
 describe("ERC20PeggedVariableCriteriaIncentive with LimitedSignerValidator", () => {
+  beforeAll(async () => {
+    fixtures = await loadFixture(deployFixtures(defaultOptions));
+  });
+  beforeEach(async () => {
+    budgets = await loadFixture(fundBudget(defaultOptions, fixtures));
+  });
+
   test("enforces validator claim limit", async () => {
     const referrer = accounts[1].account!;
     const signer = accounts[0];