@boostxyz/sdk 7.6.0 → 7.8.0

package/dist/index.js

@@ -2,205 +2,208 @@ import { BOOST_REGISTRY_ADDRESS as a, BOOST_REGISTRY_ADDRESSES as i, BoostRegist
 import { BOOST_CORE_ADDRESS as n, BOOST_CORE_ADDRESSES as d, BoostCore as l, FEE_DENOMINATOR as p } from "./BoostCore.js";
 import { Boost as c, prepareBoostPayload as g } from "./Boost.js";
 import { ActionByComponentInterface as A, actionFromAddress as y } from "./Actions/Action.js";
-import { EventAction as C, FilterType as b, PrimitiveType as I, SignatureType as P, ValueType as f, anyActionParameter as v, decodeAndReorderLogArgs as u, detectSignatureType as V, getScalarValueFromTuple as S, isCriteriaFieldIndexTuple as R, isEventActionPayloadSimple as x, packCriteriaFieldIndexes as B, packFieldIndexes as T, prepareEventActionPayload as D, transactionSenderClaimant as F, unpackCriteriaFieldIndexes as L, unpackFieldIndexes as h } from "./Actions/EventAction.js";
-import { A as M, O as N, a as w, b as _, p as U } from "./AllowList-D_K4S6jV.js";
-import { LIST_MANAGER_ROLE as G, SimpleAllowList as k, prepareSimpleAllowListPayload as z } from "./AllowLists/SimpleAllowList.js";
-import { S as Y, p as j } from "./SimpleDenyList-tEOqSTnD.js";
-import { B as J, M as K, a as Q, T as X, b as Z, p as $, c as ee } from "./Budget-DZlb1py_.js";
-import { ManagedBudget as ae, ManagedBudgetRoles as ie, isERC1155TransferPayload as oe, isFungibleTransfer as te, prepareManagedBudgetPayload as ne, prepareTransfer as de } from "./Budgets/ManagedBudget.js";
-import { Deployable as pe } from "./Deployable/Deployable.js";
-import { Contract as ce } from "./Deployable/Contract.js";
-import { DeployableTarget as me } from "./Deployable/DeployableTarget.js";
-import { DeployableTargetWithRBAC as ye, Roles as Ee } from "./Deployable/DeployableTargetWithRBAC.js";
-import { AllowListIncentive as be, prepareAllowListIncentivePayload as Ie } from "./Incentives/AllowListIncentive.js";
-import { CGDAIncentive as fe, prepareCGDAIncentivePayload as ve } from "./Incentives/CGDAIncentive.js";
-import { ERC20Incentive as Ve, prepareERC20IncentivePayload as Se } from "./Incentives/ERC20Incentive.js";
-import { E as xe, I as Be, i as Te, p as De } from "./Incentive-BKZisyIm.js";
-import { ERC20VariableIncentive as Le, prepareERC20VariableIncentivePayload as he } from "./Incentives/ERC20VariableIncentive.js";
-import { ERC20VariableCriteriaIncentive as Me, gasRebateIncentiveCriteria as Ne, prepareERC20VariableCriteriaIncentivePayload as we } from "./Incentives/ERC20VariableCriteriaIncentive.js";
-import { ERC20PeggedVariableCriteriaIncentive as Ue, prepareERC20PeggedVariableCriteriaIncentivePayload as We } from "./Incentives/ERC20PeggedVariableCriteriaIncentive.js";
-import { ERC20VariableCriteriaIncentiveV2 as ke, gasRebateIncentiveCriteriaV2 as ze, prepareERC20VariableCriteriaIncentiveV2Payload as qe } from "./Incentives/ERC20VariableCriteriaIncentiveV2.js";
-import { ERC20PeggedVariableCriteriaIncentiveV2 as je, prepareERC20PeggedVariableCriteriaIncentiveV2Payload as He } from "./Incentives/ERC20PeggedVariableCriteriaIncentiveV2.js";
-import { PointsIncentive as Ke, preparePointsIncentivePayload as Qe } from "./Incentives/PointsIncentive.js";
-import { SignerValidator as Ze, prepareSignerValidatorClaimDataPayload as $e, prepareSignerValidatorInputParams as er, prepareSignerValidatorPayload as rr } from "./Validators/SignerValidator.js";
-import { LimitedSignerValidator as ir, prepareLimitedSignerValidatorClaimDataPayload as or, prepareLimitedSignerValidatorInputParams as tr, prepareLimitedSignerValidatorPayload as nr } from "./Validators/LimitedSignerValidator.js";
-import { B as lr, P as pr, V as sr, d as cr, p as gr, a as mr, b as Ar, v as yr } from "./Validator-ztOItKpP.js";
-import { BoostCoreNoIdentifierEmitted as Cr, BoostNotFoundError as br, BudgetMustAuthorizeBoostCore as Ir, ContractAddressRequiredError as Pr, DecodedArgsError as fr, DecodedArgsMalformedError as vr, DeployableAlreadyDeployedError as ur, DeployableBuildParametersUnspecifiedError as Vr, DeployableMissingPayloadError as Sr, DeployableUnknownOwnerProvidedError as Rr, DeployableWagmiConfigurationRequiredError as xr, FieldActionValidationError as Br, FieldValueNotComparableError as Tr, FieldValueUndefinedError as Dr, FunctionDataDecodeError as Fr, IncentiveCriteriaNotFoundError as Lr, IncentiveNotCloneableError as hr, InvalidComponentInterfaceError as Or, InvalidCriteriaTypeError as Mr, InvalidNumericalCriteriaError as Nr, InvalidProtocolChainIdError as wr, InvalidTupleDecodingError as _r, InvalidTupleEncodingError as Ur, MustInitializeBudgetError as Wr, NoConnectedChainIdError as Gr, NoContractAddressUponReceiptError as kr, NoEventActionStepsProvidedError as zr, NoMatchingLogsError as qr, TooManyEventActionStepsProvidedError as Yr, UnknownTransferPayloadSupplied as jr, UnparseableAbiParamError as Hr, UnrecognizedFilterTypeError as Jr, ValidationAbiMissingError as Kr } from "./errors.js";
-import { CheatCodes as Xr, RegistryType as Zr, TRANSFER_SIGNATURE as $r, assertValidAddressByChainId as ea, awaitResult as ra, bytes4 as aa, getDeployedContractAddress as ia, getErc20Balance as oa } from "./utils.js";
-import { StrategyType as na, prepareClaimPayload as da } from "./claiming.js";
-import { AssetType as pa, prepareERC1155Payload as sa, prepareERC1155Transfer as ca, prepareFungiblePayload as ga, prepareFungibleTransfer as ma, prepareTransferPayload as Aa } from "./transfers.js";
-import { PassthroughAuth as Ea } from "./Auth/PassthroughAuth.js";
-import { q as ba, a as Ia, R as Pa, z as fa, T as va, g as ua, y as Va, d as Sa, c as Ra, m as xa, O as Ba, G as Ta, C as Da, p as Fa, r as La, M as ha, e as Oa, _ as Ma, H as Na, D as wa, j as _a, S as Ua, P as Wa, b as Ga } from "./generated-B6mEIx8i.js";
+import { EventAction as E, FilterType as b, PrimitiveType as I, SignatureType as P, ValueType as f, anyActionParameter as u, decodeAndReorderLogArgs as v, detectSignatureType as V, getScalarValueFromTuple as S, isClaimantFieldIndexTuple as R, isCriteriaFieldIndexTuple as x, isEventActionPayloadSimple as B, packClaimantFieldIndexes as T, packCriteriaFieldIndexes as D, packFieldIndexes as F, prepareEventActionPayload as L, transactionSenderClaimant as h, unpackClaimantFieldIndexes as O, unpackCriteriaFieldIndexes as M, unpackFieldIndexes as N } from "./Actions/EventAction.js";
+import { A as _, O as k, a as U, b as W, p as G } from "./AllowList-DiU7g4Hs.js";
+import { LIST_MANAGER_ROLE as q, SimpleAllowList as Y, prepareSimpleAllowListPayload as j } from "./AllowLists/SimpleAllowList.js";
+import { S as J, p as K } from "./SimpleDenyList-Dr03aOeP.js";
+import { B as X, M as Z, a as $, T as ee, b as re, p as ae, c as ie } from "./Budget-YIhV65cc.js";
+import { ManagedBudget as te, ManagedBudgetRoles as ne, isERC1155TransferPayload as de, isFungibleTransfer as le, prepareManagedBudgetPayload as pe, prepareTransfer as se } from "./Budgets/ManagedBudget.js";
+import { Deployable as ge } from "./Deployable/Deployable.js";
+import { Contract as Ae } from "./Deployable/Contract.js";
+import { DeployableTarget as Ce } from "./Deployable/DeployableTarget.js";
+import { DeployableTargetWithRBAC as be, Roles as Ie } from "./Deployable/DeployableTargetWithRBAC.js";
+import { AllowListIncentive as fe, prepareAllowListIncentivePayload as ue } from "./Incentives/AllowListIncentive.js";
+import { CGDAIncentive as Ve, prepareCGDAIncentivePayload as Se } from "./Incentives/CGDAIncentive.js";
+import { ERC20Incentive as xe, prepareERC20IncentivePayload as Be } from "./Incentives/ERC20Incentive.js";
+import { E as De, I as Fe, i as Le, p as he } from "./Incentive-CeoEla-t.js";
+import { ERC20VariableIncentive as Me, prepareERC20VariableIncentivePayload as Ne } from "./Incentives/ERC20VariableIncentive.js";
+import { ERC20VariableCriteriaIncentive as _e, gasRebateIncentiveCriteria as ke, prepareERC20VariableCriteriaIncentivePayload as Ue } from "./Incentives/ERC20VariableCriteriaIncentive.js";
+import { ERC20PeggedVariableCriteriaIncentive as Ge, prepareERC20PeggedVariableCriteriaIncentivePayload as ze } from "./Incentives/ERC20PeggedVariableCriteriaIncentive.js";
+import { ERC20VariableCriteriaIncentiveV2 as Ye, gasRebateIncentiveCriteriaV2 as je, prepareERC20VariableCriteriaIncentiveV2Payload as He } from "./Incentives/ERC20VariableCriteriaIncentiveV2.js";
+import { ERC20PeggedVariableCriteriaIncentiveV2 as Ke, prepareERC20PeggedVariableCriteriaIncentiveV2Payload as Qe } from "./Incentives/ERC20PeggedVariableCriteriaIncentiveV2.js";
+import { PointsIncentive as Ze, preparePointsIncentivePayload as $e } from "./Incentives/PointsIncentive.js";
+import { SignerValidator as rr, prepareSignerValidatorClaimDataPayload as ar, prepareSignerValidatorInputParams as ir, prepareSignerValidatorPayload as or } from "./Validators/SignerValidator.js";
+import { LimitedSignerValidator as nr, prepareLimitedSignerValidatorClaimDataPayload as dr, prepareLimitedSignerValidatorInputParams as lr, prepareLimitedSignerValidatorPayload as pr } from "./Validators/LimitedSignerValidator.js";
+import { B as cr, P as gr, V as mr, d as Ar, p as yr, a as Cr, b as Er, v as br } from "./Validator-DgvB9wge.js";
+import { BoostCoreNoIdentifierEmitted as Pr, BoostNotFoundError as fr, BudgetMustAuthorizeBoostCore as ur, ContractAddressRequiredError as vr, DecodedArgsError as Vr, DecodedArgsMalformedError as Sr, DeployableAlreadyDeployedError as Rr, DeployableBuildParametersUnspecifiedError as xr, DeployableMissingPayloadError as Br, DeployableUnknownOwnerProvidedError as Tr, DeployableWagmiConfigurationRequiredError as Dr, FieldActionValidationError as Fr, FieldValueNotComparableError as Lr, FieldValueUndefinedError as hr, FunctionDataDecodeError as Or, IncentiveCriteriaNotFoundError as Mr, IncentiveNotCloneableError as Nr, InvalidComponentInterfaceError as wr, InvalidCriteriaTypeError as _r, InvalidNumericalCriteriaError as kr, InvalidProtocolChainIdError as Ur, InvalidTupleDecodingError as Wr, InvalidTupleEncodingError as Gr, MustInitializeBudgetError as zr, NoConnectedChainIdError as qr, NoContractAddressUponReceiptError as Yr, NoEventActionStepsProvidedError as jr, NoMatchingLogsError as Hr, TooManyEventActionStepsProvidedError as Jr, UnknownTransferPayloadSupplied as Kr, UnparseableAbiParamError as Qr, UnrecognizedFilterTypeError as Xr, ValidationAbiMissingError as Zr } from "./errors.js";
+import { CheatCodes as ea, RegistryType as ra, TRANSFER_SIGNATURE as aa, assertValidAddressByChainId as ia, awaitResult as oa, bytes4 as ta, getDeployedContractAddress as na, getErc20Balance as da } from "./utils.js";
+import { StrategyType as pa, prepareClaimPayload as sa } from "./claiming.js";
+import { AssetType as ga, prepareERC1155Payload as ma, prepareERC1155Transfer as Aa, prepareFungiblePayload as ya, prepareFungibleTransfer as Ca, prepareTransferPayload as Ea } from "./transfers.js";
+import { PassthroughAuth as Ia } from "./Auth/PassthroughAuth.js";
+import { q as fa, a as ua, R as va, z as Va, T as Sa, g as Ra, y as xa, d as Ba, c as Ta, m as Da, O as Fa, G as La, C as ha, p as Oa, r as Ma, M as Na, e as wa, _ as _a, H as ka, D as Ua, j as Wa, S as Ga, P as za, b as qa } from "./generated-B6mEIx8i.js";
 export {
   A as ActionByComponentInterface,
-  M as AllowListByComponentInterface,
-  be as AllowListIncentive,
-  pa as AssetType,
+  _ as AllowListByComponentInterface,
+  fe as AllowListIncentive,
+  ga as AssetType,
   n as BOOST_CORE_ADDRESS,
   d as BOOST_CORE_ADDRESSES,
   a as BOOST_REGISTRY_ADDRESS,
   i as BOOST_REGISTRY_ADDRESSES,
   c as Boost,
   l as BoostCore,
-  Cr as BoostCoreNoIdentifierEmitted,
-  br as BoostNotFoundError,
+  Pr as BoostCoreNoIdentifierEmitted,
+  fr as BoostNotFoundError,
   o as BoostRegistry,
-  lr as BoostValidatorEOA,
-  J as BudgetByComponentInterface,
-  Ir as BudgetMustAuthorizeBoostCore,
-  fe as CGDAIncentive,
-  Xr as CheatCodes,
-  ce as Contract,
-  Pr as ContractAddressRequiredError,
-  fr as DecodedArgsError,
-  vr as DecodedArgsMalformedError,
-  pe as Deployable,
-  ur as DeployableAlreadyDeployedError,
-  Vr as DeployableBuildParametersUnspecifiedError,
-  Sr as DeployableMissingPayloadError,
-  me as DeployableTarget,
-  ye as DeployableTargetWithRBAC,
-  Rr as DeployableUnknownOwnerProvidedError,
-  xr as DeployableWagmiConfigurationRequiredError,
-  Ve as ERC20Incentive,
-  xe as ERC20PeggedIncentive,
-  Ue as ERC20PeggedVariableCriteriaIncentive,
-  je as ERC20PeggedVariableCriteriaIncentiveV2,
-  Me as ERC20VariableCriteriaIncentive,
-  ke as ERC20VariableCriteriaIncentiveV2,
-  Le as ERC20VariableIncentive,
-  C as EventAction,
+  cr as BoostValidatorEOA,
+  X as BudgetByComponentInterface,
+  ur as BudgetMustAuthorizeBoostCore,
+  Ve as CGDAIncentive,
+  ea as CheatCodes,
+  Ae as Contract,
+  vr as ContractAddressRequiredError,
+  Vr as DecodedArgsError,
+  Sr as DecodedArgsMalformedError,
+  ge as Deployable,
+  Rr as DeployableAlreadyDeployedError,
+  xr as DeployableBuildParametersUnspecifiedError,
+  Br as DeployableMissingPayloadError,
+  Ce as DeployableTarget,
+  be as DeployableTargetWithRBAC,
+  Tr as DeployableUnknownOwnerProvidedError,
+  Dr as DeployableWagmiConfigurationRequiredError,
+  xe as ERC20Incentive,
+  De as ERC20PeggedIncentive,
+  Ge as ERC20PeggedVariableCriteriaIncentive,
+  Ke as ERC20PeggedVariableCriteriaIncentiveV2,
+  _e as ERC20VariableCriteriaIncentive,
+  Ye as ERC20VariableCriteriaIncentiveV2,
+  Me as ERC20VariableIncentive,
+  E as EventAction,
   p as FEE_DENOMINATOR,
-  Br as FieldActionValidationError,
-  Tr as FieldValueNotComparableError,
-  Dr as FieldValueUndefinedError,
+  Fr as FieldActionValidationError,
+  Lr as FieldValueNotComparableError,
+  hr as FieldValueUndefinedError,
   b as FilterType,
-  Fr as FunctionDataDecodeError,
-  Be as IncentiveByComponentInterface,
-  Lr as IncentiveCriteriaNotFoundError,
-  hr as IncentiveNotCloneableError,
-  Or as InvalidComponentInterfaceError,
-  Mr as InvalidCriteriaTypeError,
-  Nr as InvalidNumericalCriteriaError,
-  wr as InvalidProtocolChainIdError,
-  _r as InvalidTupleDecodingError,
-  Ur as InvalidTupleEncodingError,
-  G as LIST_MANAGER_ROLE,
-  ir as LimitedSignerValidator,
-  ae as ManagedBudget,
-  ie as ManagedBudgetRoles,
-  K as ManagedBudgetWithFees,
-  Q as ManagedBudgetWithFeesV2,
-  Wr as MustInitializeBudgetError,
-  Gr as NoConnectedChainIdError,
-  kr as NoContractAddressUponReceiptError,
-  zr as NoEventActionStepsProvidedError,
-  qr as NoMatchingLogsError,
-  N as OffchainAccessList,
-  w as OpenAllowList,
-  Ea as PassthroughAuth,
-  pr as PayableLimitedSignerValidator,
-  Ke as PointsIncentive,
+  Or as FunctionDataDecodeError,
+  Fe as IncentiveByComponentInterface,
+  Mr as IncentiveCriteriaNotFoundError,
+  Nr as IncentiveNotCloneableError,
+  wr as InvalidComponentInterfaceError,
+  _r as InvalidCriteriaTypeError,
+  kr as InvalidNumericalCriteriaError,
+  Ur as InvalidProtocolChainIdError,
+  Wr as InvalidTupleDecodingError,
+  Gr as InvalidTupleEncodingError,
+  q as LIST_MANAGER_ROLE,
+  nr as LimitedSignerValidator,
+  te as ManagedBudget,
+  ne as ManagedBudgetRoles,
+  Z as ManagedBudgetWithFees,
+  $ as ManagedBudgetWithFeesV2,
+  zr as MustInitializeBudgetError,
+  qr as NoConnectedChainIdError,
+  Yr as NoContractAddressUponReceiptError,
+  jr as NoEventActionStepsProvidedError,
+  Hr as NoMatchingLogsError,
+  k as OffchainAccessList,
+  U as OpenAllowList,
+  Ia as PassthroughAuth,
+  gr as PayableLimitedSignerValidator,
+  Ze as PointsIncentive,
   I as PrimitiveType,
-  Zr as RegistryType,
-  Ee as Roles,
+  ra as RegistryType,
+  Ie as Roles,
   P as SignatureType,
-  Ze as SignerValidator,
-  k as SimpleAllowList,
-  Y as SimpleDenyList,
-  na as StrategyType,
-  $r as TRANSFER_SIGNATURE,
-  Yr as TooManyEventActionStepsProvidedError,
-  X as TransparentBudget,
-  jr as UnknownTransferPayloadSupplied,
-  Hr as UnparseableAbiParamError,
-  Jr as UnrecognizedFilterTypeError,
-  Kr as ValidationAbiMissingError,
-  sr as ValidatorByComponentInterface,
+  rr as SignerValidator,
+  Y as SimpleAllowList,
+  J as SimpleDenyList,
+  pa as StrategyType,
+  aa as TRANSFER_SIGNATURE,
+  Jr as TooManyEventActionStepsProvidedError,
+  ee as TransparentBudget,
+  Kr as UnknownTransferPayloadSupplied,
+  Qr as UnparseableAbiParamError,
+  Xr as UnrecognizedFilterTypeError,
+  Zr as ValidationAbiMissingError,
+  mr as ValidatorByComponentInterface,
   f as ValueType,
   y as actionFromAddress,
-  _ as allowListFromAddress,
-  ba as allowListIncentiveAbi,
-  v as anyActionParameter,
-  ea as assertValidAddressByChainId,
-  ra as awaitResult,
-  Ia as boostCoreAbi,
-  Pa as boostRegistryAbi,
-  Z as budgetFromAddress,
-  aa as bytes4,
-  fa as cgdaIncentiveAbi,
-  u as decodeAndReorderLogArgs,
-  cr as decodeClaimData,
+  W as allowListFromAddress,
+  fa as allowListIncentiveAbi,
+  u as anyActionParameter,
+  ia as assertValidAddressByChainId,
+  oa as awaitResult,
+  ua as boostCoreAbi,
+  va as boostRegistryAbi,
+  re as budgetFromAddress,
+  ta as bytes4,
+  Va as cgdaIncentiveAbi,
+  v as decodeAndReorderLogArgs,
+  Ar as decodeClaimData,
   V as detectSignatureType,
-  va as erc20IncentiveAbi,
-  ua as erc20PeggedIncentiveAbi,
-  Va as erc20PeggedVariableCriteriaIncentiveAbi,
-  Sa as erc20PeggedVariableCriteriaIncentiveV2Abi,
-  Ra as erc20VariableCriteriaIncentiveAbi,
-  xa as erc20VariableCriteriaIncentiveV2Abi,
-  Ba as erc20VariableIncentiveAbi,
-  Ne as gasRebateIncentiveCriteria,
-  ze as gasRebateIncentiveCriteriaV2,
-  ia as getDeployedContractAddress,
-  oa as getErc20Balance,
+  Sa as erc20IncentiveAbi,
+  Ra as erc20PeggedIncentiveAbi,
+  xa as erc20PeggedVariableCriteriaIncentiveAbi,
+  Ba as erc20PeggedVariableCriteriaIncentiveV2Abi,
+  Ta as erc20VariableCriteriaIncentiveAbi,
+  Da as erc20VariableCriteriaIncentiveV2Abi,
+  Fa as erc20VariableIncentiveAbi,
+  ke as gasRebateIncentiveCriteria,
+  je as gasRebateIncentiveCriteriaV2,
+  na as getDeployedContractAddress,
+  da as getErc20Balance,
   S as getScalarValueFromTuple,
-  Te as incentiveFromAddress,
-  R as isCriteriaFieldIndexTuple,
-  oe as isERC1155TransferPayload,
-  x as isEventActionPayloadSimple,
-  te as isFungibleTransfer,
-  Ta as limitedSignerValidatorAbi,
-  Da as managedBudgetAbi,
-  Fa as managedBudgetWithFeesAbi,
-  La as managedBudgetWithFeesV2Abi,
-  ha as offchainAccessListAbi,
-  B as packCriteriaFieldIndexes,
-  T as packFieldIndexes,
-  Oa as passthroughAuthAbi,
-  Ma as payableLimitedSignerValidatorAbi,
-  Na as pointsIncentiveAbi,
-  Ie as prepareAllowListIncentivePayload,
+  Le as incentiveFromAddress,
+  R as isClaimantFieldIndexTuple,
+  x as isCriteriaFieldIndexTuple,
+  de as isERC1155TransferPayload,
+  B as isEventActionPayloadSimple,
+  le as isFungibleTransfer,
+  La as limitedSignerValidatorAbi,
+  ha as managedBudgetAbi,
+  Oa as managedBudgetWithFeesAbi,
+  Ma as managedBudgetWithFeesV2Abi,
+  Na as offchainAccessListAbi,
+  T as packClaimantFieldIndexes,
+  D as packCriteriaFieldIndexes,
+  F as packFieldIndexes,
+  wa as passthroughAuthAbi,
+  _a as payableLimitedSignerValidatorAbi,
+  ka as pointsIncentiveAbi,
+  ue as prepareAllowListIncentivePayload,
   g as prepareBoostPayload,
-  ve as prepareCGDAIncentivePayload,
-  da as prepareClaimPayload,
-  sa as prepareERC1155Payload,
-  ca as prepareERC1155Transfer,
-  Se as prepareERC20IncentivePayload,
-  De as prepareERC20PeggedIncentivePayload,
-  We as prepareERC20PeggedVariableCriteriaIncentivePayload,
-  He as prepareERC20PeggedVariableCriteriaIncentiveV2Payload,
-  we as prepareERC20VariableCriteriaIncentivePayload,
-  qe as prepareERC20VariableCriteriaIncentiveV2Payload,
-  he as prepareERC20VariableIncentivePayload,
-  D as prepareEventActionPayload,
-  ga as prepareFungiblePayload,
-  ma as prepareFungibleTransfer,
-  or as prepareLimitedSignerValidatorClaimDataPayload,
-  tr as prepareLimitedSignerValidatorInputParams,
-  nr as prepareLimitedSignerValidatorPayload,
-  ne as prepareManagedBudgetPayload,
-  $ as prepareManagedBudgetWithFeesPayload,
-  ee as prepareManagedBudgetWithFeesV2Payload,
-  U as prepareOffchainAccessListPayload,
-  gr as preparePayableLimitedSignerValidatorClaimDataPayload,
-  mr as preparePayableLimitedSignerValidatorInputParams,
-  Ar as preparePayableLimitedSignerValidatorPayload,
-  Qe as preparePointsIncentivePayload,
-  $e as prepareSignerValidatorClaimDataPayload,
-  er as prepareSignerValidatorInputParams,
-  rr as prepareSignerValidatorPayload,
-  z as prepareSimpleAllowListPayload,
-  j as prepareSimpleDenyListPayload,
-  de as prepareTransfer,
-  Aa as prepareTransferPayload,
-  wa as rbacAbi,
-  _a as signerValidatorAbi,
-  Ua as simpleAllowListAbi,
-  Wa as simpleDenyListAbi,
-  F as transactionSenderClaimant,
-  Ga as transparentBudgetAbi,
-  L as unpackCriteriaFieldIndexes,
-  h as unpackFieldIndexes,
-  yr as validatorFromAddress
+  Se as prepareCGDAIncentivePayload,
+  sa as prepareClaimPayload,
+  ma as prepareERC1155Payload,
+  Aa as prepareERC1155Transfer,
+  Be as prepareERC20IncentivePayload,
+  he as prepareERC20PeggedIncentivePayload,
+  ze as prepareERC20PeggedVariableCriteriaIncentivePayload,
+  Qe as prepareERC20PeggedVariableCriteriaIncentiveV2Payload,
+  Ue as prepareERC20VariableCriteriaIncentivePayload,
+  He as prepareERC20VariableCriteriaIncentiveV2Payload,
+  Ne as prepareERC20VariableIncentivePayload,
+  L as prepareEventActionPayload,
+  ya as prepareFungiblePayload,
+  Ca as prepareFungibleTransfer,
+  dr as prepareLimitedSignerValidatorClaimDataPayload,
+  lr as prepareLimitedSignerValidatorInputParams,
+  pr as prepareLimitedSignerValidatorPayload,
+  pe as prepareManagedBudgetPayload,
+  ae as prepareManagedBudgetWithFeesPayload,
+  ie as prepareManagedBudgetWithFeesV2Payload,
+  G as prepareOffchainAccessListPayload,
+  yr as preparePayableLimitedSignerValidatorClaimDataPayload,
+  Cr as preparePayableLimitedSignerValidatorInputParams,
+  Er as preparePayableLimitedSignerValidatorPayload,
+  $e as preparePointsIncentivePayload,
+  ar as prepareSignerValidatorClaimDataPayload,
+  ir as prepareSignerValidatorInputParams,
+  or as prepareSignerValidatorPayload,
+  j as prepareSimpleAllowListPayload,
+  K as prepareSimpleDenyListPayload,
+  se as prepareTransfer,
+  Ea as prepareTransferPayload,
+  Ua as rbacAbi,
+  Wa as signerValidatorAbi,
+  Ga as simpleAllowListAbi,
+  za as simpleDenyListAbi,
+  h as transactionSenderClaimant,
+  qa as transparentBudgetAbi,
+  O as unpackClaimantFieldIndexes,
+  M as unpackCriteriaFieldIndexes,
+  N as unpackFieldIndexes,
+  br as validatorFromAddress
 };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boostxyz/sdk",
-  "version": "7.6.0",
+  "version": "7.8.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.