@boostxyz/sdk 5.2.0 → 5.3.0

package/src/BoostCore.test.ts

@@ -17,6 +17,8 @@ import { BoostNotFoundError, IncentiveNotCloneableError } from "./errors";
 import type { ERC20Incentive } from "./Incentives/ERC20Incentive";
 import { bytes4 } from "./utils";
 import { BoostValidatorEOA } from "./Validators/Validator";
+import { AssetType } from "./transfers";
+import { waitForTransactionReceipt } from "@wagmi/core";
 
 let fixtures: Fixtures, budgets: BudgetFixtures;
 
@@ -32,7 +34,7 @@ describe("BoostCore", () => {
     const { core } = fixtures;
 
     const { budget, erc20 } = budgets;
-    await core.createBoost({
+    const payload = {
       protocolFee: 0n,
       maxParticipants: 5n,
       budget: budget,
@@ -59,8 +61,11 @@ describe("BoostCore", () => {
           manager: budget.assertValidAddress(),
         }),
       ],
-    });
-    expect(await core.getBoostCount()).toBe(1n);
+    }
+    const { hash } = await core.createBoostRaw(payload)
+    await waitForTransactionReceipt(defaultOptions.config, { hash })
+    await core.createBoost(payload);
+    expect(await core.getBoostCount()).toBe(2n);
   });
 
   test("throws a typed error if no boost exists", async () => {
@@ -904,4 +909,47 @@ describe("BoostCore", () => {
     )
     expect(totalFee).toBe(100000000000000000n)
   });
+
+  test("can get incentive fees information", async () => {
+    const { core } = fixtures;
+    const { budget, erc20 } = budgets;
+
+    // Create a new boost
+    const boost = await core.createBoost({
+      protocolFee: 0n,
+      maxParticipants: 10n,
+      budget: budget,
+      action: core.EventAction(
+        makeMockEventActionPayload(
+          core.assertValidAddress(),
+          erc20.assertValidAddress(),
+        ),
+      ),
+      validator: core.SignerValidator({
+        signers: [defaultOptions.account.address],
+        validatorCaller: defaultOptions.account.address,
+      }),
+      allowList: core.SimpleAllowList({
+        owner: defaultOptions.account.address,
+        allowed: [defaultOptions.account.address],
+      }),
+      incentives: [
+        core.ERC20Incentive({
+          asset: erc20.assertValidAddress(),
+          reward: parseEther("1"),
+          limit: 10n,
+          strategy: StrategyType.POOL,
+          manager: budget.assertValidAddress(),
+        }),
+      ],
+    });
+
+    const feesInfo = await core.getIncentiveFeesInfo(boost.id, 0n);
+
+    expect(feesInfo).toBeDefined();
+    expect(feesInfo.protocolFee).toBe(1000n);
+    expect(feesInfo.protocolFeesRemaining).toBe(parseEther("1"));
+    expect(feesInfo.assetType).toBe(AssetType.ERC20);
+    expect(feesInfo.asset.toLowerCase()).toBe(erc20.assertValidAddress());
+  });
 });

package/src/BoostCore.ts

@@ -3,6 +3,7 @@ import {
   readBoostCoreCreateBoostAuth,
   readBoostCoreGetBoost,
   readBoostCoreGetBoostCount,
+  readBoostCoreGetIncentiveFeesInfo,
   readBoostCoreProtocolFee,
   readBoostCoreProtocolFeeReceiver,
   readIAuthIsAuthorized,
@@ -13,6 +14,7 @@ import {
   simulateBoostCoreSetProtocolFeeReceiver,
   writeBoostCoreClaimIncentive,
   writeBoostCoreClaimIncentiveFor,
+  writeBoostCoreCreateBoost,
   writeBoostCoreSetCreateBoostAuth,
   writeBoostCoreSetProtocolFeeReceiver,
 } from '@boostxyz/evm';
@@ -29,6 +31,8 @@ import {
   type Address,
   type ContractEventName,
   type Hex,
+  encodePacked,
+  keccak256,
   parseEventLogs,
   zeroAddress,
   zeroHash,
@@ -126,8 +130,10 @@ import {
   InvalidProtocolChainIdError,
   MustInitializeBudgetError,
 } from './errors';
+import type { AssetType } from './transfers';
 import {
   type GenericLog,
+  type HashAndSimulatedResult,
   type ReadParams,
   type WriteParams,
   assertValidAddressByChainId,
@@ -275,6 +281,20 @@ export type CreateBoostPayload = {
   owner?: Address;
 };
 
+/**
+ * Represents the information about the disbursal of an incentive.
+ *
+ * @export
+ * @typedef {IncentiveDisbursalInfo}
+ */
+export type IncentiveDisbursalInfo = {
+  assetType: AssetType;
+  asset: Address;
+  protocolFeesRemaining: bigint;
+  protocolFee: bigint;
+  tokenId: bigint;
+};
+
 /**
  * The core contract for the Boost protocol. Used to create and retrieve deployed Boosts.
  *
@@ -407,6 +427,27 @@ export class BoostCore extends Deployable<
     });
   }
 
+  /**
+   * Create a new Boost.
+   *
+   * @public
+   * @async
+   * @param {CreateBoostPayload} _boostPayload
+   * @param {?WriteParams} [params]
+   * @returns {Promise<HashAndSimulatedResult>}
+   */
+  public async createBoostRaw(
+    _boostPayload: CreateBoostPayload,
+    _params?: WriteParams,
+  ): Promise<HashAndSimulatedResult> {
+    const { request, result } = await this.simulateCreateBoost(
+      _boostPayload,
+      _params,
+    );
+    const hash = await writeBoostCoreCreateBoost(this._config, request);
+    return { hash, result };
+  }
+
   /**
    * Returns a simulated Boost creation.
    *
@@ -1046,6 +1087,38 @@ export class BoostCore extends Deployable<
     return { hash, result };
   }
 
+  /**
+   * Get the incentives fees information for a given Boost ID and Incentive ID.
+   *
+   * @public
+   * @async
+   * @param {bigint} boostId - The ID of the Boost
+   * @param {bigint} incentiveId - The ID of the Incentive
+   * @param {?ReadParams} [params]
+   * @returns {Promise<IncentiveDisbursalInfo>}
+   */
+  public async getIncentiveFeesInfo(
+    boostId: bigint,
+    incentiveId: bigint,
+    params?: ReadParams,
+  ) {
+    const key = keccak256(
+      encodePacked(['uint256', 'uint256'], [boostId, incentiveId]),
+    );
+
+    return await readBoostCoreGetIncentiveFeesInfo(this._config, {
+      ...assertValidAddressByChainId(
+        this._config,
+        this.addresses,
+        params?.chainId,
+      ),
+      args: [key],
+      ...this.optionallyAttachAccount(),
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
+    });
+  }
+
   /**
    * Retrieves the claim information from a transaction receipt.
    *

package/src/Incentives/ERC20PeggedIncentive.ts

@@ -21,9 +21,9 @@ import {
   type Address,
   type ContractEventName,
   type Hex,
+  decodeAbiParameters,
   encodeAbiParameters,
   zeroAddress,
-  zeroHash,
 } from 'viem';
 import { ERC20PeggedIncentive as ERC20PeggedIncentiveBases } from '../../dist/deployments.json';
 import type {
@@ -422,11 +422,11 @@ export class ERC20PeggedIncentive extends DeployableTarget<
    * @returns {Promise<bigint>} - True if total claims is less than limit
    */
   public async getRemainingClaimPotential(params?: ReadParams) {
-    const [claims, limit] = await Promise.all([
-      this.claims(params),
+    const [totalClaimed, limit] = await Promise.all([
+      this.totalClaimed(params),
       this.limit(params),
     ]);
-    return limit - claims;
+    return limit - totalClaimed;
   }
 
   /**
@@ -478,6 +478,35 @@ export class ERC20PeggedIncentive extends DeployableTarget<
       [rewardAmount],
     );
   }
+
+  /**
+   * Decodes claim data for the ERC20PeggedIncentive, returning the claim amount.
+   * Useful when deriving amount claimed from logs.
+   *
+   * @public
+   * @param {Hex} claimData
+   * @returns {BigInt} Returns the reward amount from a claim data payload
+   */
+  public decodeClaimData(claimData: Hex) {
+    const boostClaimData = decodeAbiParameters(
+      [
+        {
+          type: 'tuple',
+          name: 'BoostClaimData',
+          components: [
+            { type: 'bytes', name: 'validatorData' },
+            { type: 'bytes', name: 'incentiveData' },
+          ],
+        },
+      ],
+      claimData,
+    );
+    const signedAmount = decodeAbiParameters(
+      [{ type: 'uint256' }],
+      boostClaimData[0].incentiveData,
+    )[0];
+    return signedAmount;
+  }
 }
 
 /**

package/src/Incentives/ERC20PeggedVariableCriteriaIncentive.test.ts

@@ -33,6 +33,7 @@ import {
   gasRebateIncentiveCriteria,
 } from "./ERC20VariableCriteriaIncentive";
 import { allKnownSignatures } from "@boostxyz/test/allKnownSignatures";
+import { readMockErc20BalanceOf } from "@boostxyz/evm";
 
 /**
  * A basic ERC721 mint scalar criteria for testing
@@ -73,11 +74,11 @@ export function basicErc721MintScalarCriteria(
 let fixtures: Fixtures,
   erc20: MockERC20,
   erc721: MockERC721,
-  erc20Incentive: ERC20PeggedVariableCriteriaIncentive,
+  erc20PeggedVariableCriteriaIncentive: ERC20PeggedVariableCriteriaIncentive,
   budgets: BudgetFixtures,
   boost: Boost;
 
-describe("ERC20VariableCriteriaIncentive", () => {
+describe("ERC20PeggedVariableCriteriaIncentive", () => {
   beforeAll(async () => {
     fixtures = await loadFixture(deployFixtures(defaultOptions));
   });
@@ -86,7 +87,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
     budgets = await loadFixture(fundBudget(defaultOptions, fixtures));
     erc20 = await loadFixture(fundErc20(defaultOptions));
     erc721 = await loadFixture(fundErc721(defaultOptions));
-    erc20Incentive = fixtures.core.ERC20PeggedVariableCriteriaIncentive({
+    erc20PeggedVariableCriteriaIncentive = fixtures.core.ERC20PeggedVariableCriteriaIncentive({
       asset: budgets.erc20.assertValidAddress(),
       reward: parseEther("1"),
       limit: parseEther("10"),
@@ -97,48 +98,48 @@ describe("ERC20VariableCriteriaIncentive", () => {
 
     boost = await freshBoost(fixtures, {
       budget: budgets.budget,
-      incentives: [erc20Incentive],
+      incentives: [erc20PeggedVariableCriteriaIncentive],
     });
     expect(isAddress(boost.incentives[0]!.assertValidAddress())).toBe(true);
   });
 
   describe("Basic Parameters", () => {
     test("should return correct asset address", async () => {
-      const asset = await erc20Incentive.asset();
+      const asset = await erc20PeggedVariableCriteriaIncentive.asset();
       expect(isAddressEqual(asset, budgets.erc20.assertValidAddress())).toBe(true);
     });
 
     test("should return correct peg token address", async () => {
-      const peg = await erc20Incentive.peg();
+      const peg = await erc20PeggedVariableCriteriaIncentive.peg();
       expect(isAddressEqual(peg, erc20.assertValidAddress())).toBe(true);
     });
 
     test("should return correct reward amount", async () => {
-      const reward = await erc20Incentive.reward();
+      const reward = await erc20PeggedVariableCriteriaIncentive.reward();
       expect(reward).toBe(parseEther("1"));
     });
 
     test("should return correct limit", async () => {
-      const limit = await erc20Incentive.limit();
+      const limit = await erc20PeggedVariableCriteriaIncentive.limit();
       expect(limit).toBe(parseEther("10"));
     });
 
     test("should return correct max reward", async () => {
-      const maxReward = await erc20Incentive.getMaxReward();
+      const maxReward = await erc20PeggedVariableCriteriaIncentive.getMaxReward();
       expect(maxReward).toBe(parseEther("20"));
     });
   });
 
   describe("Remaining Claims", () => {
     test("should calculate remaining claim potential correctly", async () => {
-      const remaining = await erc20Incentive.getRemainingClaimPotential();
-      const limit = await erc20Incentive.limit();
-      const totalClaimed = await erc20Incentive.totalClaimed();
+      const remaining = await erc20PeggedVariableCriteriaIncentive.getRemainingClaimPotential();
+      const limit = await erc20PeggedVariableCriteriaIncentive.limit();
+      const totalClaimed = await erc20PeggedVariableCriteriaIncentive.totalClaimed();
       expect(remaining).toBe(limit - totalClaimed);
     });
 
     test("should return true for canBeClaimed when claims remain", async () => {
-      const canBeClaimed = await erc20Incentive.canBeClaimed();
+      const canBeClaimed = await erc20PeggedVariableCriteriaIncentive.canBeClaimed();
       expect(canBeClaimed).toBe(true);
     });
   });
@@ -159,7 +160,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
   describe("Claim Data", () => {
     test("should properly encode claim data", () => {
       const rewardAmount = parseEther("1");
-      const encodedData = erc20Incentive.buildClaimData(rewardAmount);
+      const encodedData = erc20PeggedVariableCriteriaIncentive.buildClaimData(rewardAmount);
       expect(encodedData).toBe(
         "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000"
       );
@@ -168,14 +169,14 @@ describe("ERC20VariableCriteriaIncentive", () => {
 
   describe("Owner", () => {
     test("should return correct owner", async () => {
-      const owner = await erc20Incentive.owner();
+      const owner = await erc20PeggedVariableCriteriaIncentive.owner();
       expect(isAddressEqual(owner, fixtures.core.assertValidAddress())).toBe(true);
     });
   });
 
   describe("Current Reward", () => {
     test("should return valid current reward", async () => {
-      const currentReward = await erc20Incentive.currentReward();
+      const currentReward = await erc20PeggedVariableCriteriaIncentive.currentReward();
       expect(currentReward).toBeDefined();
       expect(currentReward).toBeTypeOf("bigint");
     });
@@ -190,7 +191,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
         recipient,
         1n,
       );
-      const scalar = await erc20Incentive.getIncentiveScalar({
+      const scalar = await erc20PeggedVariableCriteriaIncentive.getIncentiveScalar({
         hash,
         chainId: 31337,
         knownSignatures: allKnownSignatures,
@@ -202,7 +203,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
     test("should return a valid scalar for event-based criteria", async () => {
       boost = await freshBoost(fixtures, {
         budget: budgets.budget,
-        incentives: [erc20Incentive],
+        incentives: [erc20PeggedVariableCriteriaIncentive],
       });
       const recipient = accounts[1].account;
       const { hash } = await erc721.transferFromRaw(
@@ -210,7 +211,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
         recipient,
         1n,
       );
-      const scalar = await erc20Incentive.getIncentiveScalar({
+      const scalar = await erc20PeggedVariableCriteriaIncentive.getIncentiveScalar({
         hash,
         chainId: 31337,
         knownSignatures: allKnownSignatures,
@@ -223,7 +224,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
       // Ensure that the gasRebateIncentiveCriteria returns the correct structure
       const gasRebateCriteria = gasRebateIncentiveCriteria();
 
-      erc20Incentive = fixtures.core.ERC20PeggedVariableCriteriaIncentive({
+      erc20PeggedVariableCriteriaIncentive = fixtures.core.ERC20PeggedVariableCriteriaIncentive({
         asset: budgets.erc20.assertValidAddress(),
         reward: 1n,
         limit: 1n,
@@ -242,7 +243,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
 
       boost = await freshBoost(fixtures, {
         budget: budgets.budget,
-        incentives: [erc20Incentive],
+        incentives: [erc20PeggedVariableCriteriaIncentive],
       });
 
       // Validate that the deployed incentive has the correct criteria set up
@@ -261,7 +262,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
       const { hash } = await erc20.mintRaw(recipient, parseEther("100"));
 
       try {
-        await erc20Incentive.getIncentiveScalar({
+        await erc20PeggedVariableCriteriaIncentive.getIncentiveScalar({
           hash,
           chainId: 31337,
           knownSignatures: allKnownSignatures,
@@ -276,7 +277,7 @@ describe("ERC20VariableCriteriaIncentive", () => {
       const { hash } = await erc20.mintRaw(recipient, parseEther("100"));
 
       try {
-        await erc20Incentive.getIncentiveScalar({
+        await erc20PeggedVariableCriteriaIncentive.getIncentiveScalar({
           hash,
           chainId: 31337,
           knownSignatures: allKnownSignatures,
@@ -299,11 +300,11 @@ describe("ERC20VariableCriteriaIncentive", () => {
     // rebase this
     const boost = await freshBoost(fixtures, {
       budget: budgets.budget,
-      incentives: [erc20Incentive],
+      incentives: [erc20PeggedVariableCriteriaIncentive],
     });
     const [amount, address] = await budgets.budget.clawbackFromTarget(
       fixtures.core.assertValidAddress(),
-      erc20Incentive.buildClawbackData(1n),
+      erc20PeggedVariableCriteriaIncentive.buildClawbackData(1n),
       boost.id,
       0,
     );
@@ -312,4 +313,45 @@ describe("ERC20VariableCriteriaIncentive", () => {
       true,
     );
   });
+
+  test('can claim', async () => {
+    const referrer = accounts.at(1)?.account!
+    const trustedSigner = accounts.at(0)!
+    const claimant = trustedSigner.account!;
+    const asset = await erc20PeggedVariableCriteriaIncentive.asset()
+    const signedAmount = 2n
+    const incentiveData = erc20PeggedVariableCriteriaIncentive.buildClaimData(signedAmount)
+    const claimDataPayload = await boost.validator.encodeClaimData({
+      signer: trustedSigner,
+      incentiveData,
+      chainId: defaultOptions.config.chains[0].id,
+      incentiveQuantity: boost.incentives.length,
+      claimant,
+      boostId: boost.id
+    })
+
+    // verify reward amount
+    const incentiveClaimAmount = await erc20PeggedVariableCriteriaIncentive.decodeClaimData(claimDataPayload)
+    expect(incentiveClaimAmount).toBe(signedAmount)
+
+    const balanceBeforeClaim = await readMockErc20BalanceOf(defaultOptions.config, {
+      address: asset,
+      args: [claimant],
+    })
+
+    await fixtures.core.claimIncentiveFor(
+      boost.id,
+      0n,
+      referrer,
+      claimDataPayload,
+      claimant,
+    );
+
+    const balanceAfterClaim = await readMockErc20BalanceOf(defaultOptions.config, {
+      address: asset,
+      args: [claimant],
+    })
+
+    expect(balanceAfterClaim - balanceBeforeClaim).toBe(signedAmount);
+  })
 });

package/src/Incentives/ERC20PeggedVariableCriteriaIncentive.ts

@@ -29,6 +29,7 @@ import {
   decodeAbiParameters,
   decodeFunctionData,
   encodeAbiParameters,
+  parseEther,
   parseEventLogs,
   zeroAddress,
 } from 'viem';
@@ -651,27 +652,108 @@ export class ERC20PeggedVariableCriteriaIncentive extends DeployableTarget<
    * Builds the claim data for the ERC20PeggedVariableCriteriaIncentivePayload.
    *
    * @public
-   * @param {bigint} rewardAmount
+   * @param {bigint} signedAmount
    * @returns {Hash} Returns the encoded claim data
    * @description This function returns the encoded claim data for the ERC20PeggedVariableCriteriaIncentivePayload.
    */
-  public buildClaimData(rewardAmount: bigint) {
+  public buildClaimData(signedAmount: bigint) {
     return encodeAbiParameters(
-      [{ type: 'uint256', name: 'rewardAmount' }],
-      [rewardAmount],
+      [{ type: 'uint256', name: 'signedAmount' }],
+      [signedAmount],
     );
   }
 
   /**
-   * Decodes claim data for the ERC20PeggedVariableCriteriaIncentive, returning the encoded claim amount.
+   * Decodes claim data for the ERC20PeggedVariableCriteriaIncentive, returning the claim amount.
    * Useful when deriving amount claimed from logs.
    *
    * @public
    * @param {Hex} claimData
    * @returns {BigInt} Returns the reward amount from a claim data payload
    */
-  public decodeClaimData(data: Hex) {
-    return BigInt(decodeAbiParameters([{ type: 'uint256' }], data)[0]);
+  public async decodeClaimData(claimData: Hex) {
+    const boostClaimData = decodeAbiParameters(
+      [
+        {
+          type: 'tuple',
+          name: 'BoostClaimData',
+          components: [
+            { type: 'bytes', name: 'validatorData' },
+            { type: 'bytes', name: 'incentiveData' },
+          ],
+        },
+      ],
+      claimData,
+    );
+    const signedAmount = decodeAbiParameters(
+      [{ type: 'uint256' }],
+      boostClaimData[0].incentiveData,
+    )[0];
+    let claimAmount = signedAmount;
+    const [reward, maxReward] = await Promise.all([
+      this.reward(),
+      this.getMaxReward(),
+    ]);
+
+    if (reward === 0n) {
+      return claimAmount;
+    } else {
+      claimAmount = (reward * signedAmount) / parseEther('1');
+    }
+
+    if (maxReward !== 0n && claimAmount > maxReward) {
+      claimAmount = maxReward;
+    }
+
+    return claimAmount;
+  }
+
+  /**
+   * Decodes claim data for the ERC20PeggedVariableCriteriaIncentive, returning the claim amount.
+   * Useful when deriving amount claimed from logs.
+   * Use this function instead of `decodeClaimData` if you have reward details.
+   *
+   * @public
+   * @param {Hex} claimData
+   * @param {bigint} [reward]
+   * @param {bigint} [maxReward]
+   * @returns {BigInt} Returns the reward amount from a claim data payload
+   */
+  public decodeClaimDataWithRewardDetails(
+    claimData: Hex,
+    reward: bigint,
+    maxReward: bigint,
+  ) {
+    const boostClaimData = decodeAbiParameters(
+      [
+        {
+          type: 'tuple',
+          name: 'BoostClaimData',
+          components: [
+            { type: 'bytes', name: 'validatorData' },
+            { type: 'bytes', name: 'incentiveData' },
+          ],
+        },
+      ],
+      claimData,
+    );
+    const signedAmount = decodeAbiParameters(
+      [{ type: 'uint256' }],
+      boostClaimData[0].incentiveData,
+    )[0];
+    let claimAmount = signedAmount;
+
+    if (reward === 0n) {
+      return claimAmount;
+    } else {
+      claimAmount = (reward * signedAmount) / parseEther('1');
+    }
+
+    if (maxReward !== 0n && claimAmount > maxReward) {
+      claimAmount = maxReward;
+    }
+
+    return claimAmount;
   }
 }
 

package/src/errors.ts

@@ -865,3 +865,53 @@ export class BoostNotFoundError extends Error {
     this.id = id;
   }
 }
+
+/**
+ * Thrown when a tuple decoding operation encounters unexpected structure or data.
+ *
+ * @export
+ * @class InvalidTupleDecodingError
+ * @typedef {InvalidTupleDecodingError}
+ * @extends {Error}
+ */
+export class InvalidTupleDecodingError extends Error {
+  /**
+   * The index of the tuple that caused the error.
+   *
+   * @type {number}
+   */
+  public readonly tupleIndex: number;
+
+  /**
+   * Creates an instance of InvalidTupleDecodingError.
+   *
+   * @constructor
+   * @param {string} tupleName - The name or identifier of the tuple that failed to decode.
+   * @param {string} [message] - Optional custom message for more context.
+   */
+  constructor(message?: string, tupleIndex?: number) {
+    super(message || `Failed to decode tuple: ${tupleIndex}`);
+    this.tupleIndex = tupleIndex ?? -1;
+  }
+}
+
+export class InvalidTupleEncodingError extends Error {
+  /**
+   * The index of the tuple that caused the error.
+   *
+   * @type {number}
+   */
+  public readonly tupleIndex: number;
+
+  /**
+   * Creates an instance of InvalidTupleEncodingError.
+   *
+   * @constructor
+   * @param {string} tupleName - The name or identifier of the tuple that failed to encode.
+   * @param {string} [message] - Optional custom message for more context.
+   */
+  constructor(message?: string, tupleIndex?: number) {
+    super(message || `Failed to encode tuple: ${tupleIndex}`);
+    this.tupleIndex = tupleIndex ?? -1;
+  }
+}