@obolnetwork/obol-sdk 2.11.4 → 2.11.5-rc.1

package/src/exits/verificationHelpers.ts

@@ -1,110 +0,0 @@
-import { ContainerType, ByteVectorType, fromHexString } from '@chainsafe/ssz';
-
-// From obol-api/src/verification/common.ts
-export const GENESIS_VALIDATOR_ROOT_HEX_STRING =
-  '0x0000000000000000000000000000000000000000000000000000000000000000'; // Added 0x prefix
-
-const ForkDataType = new ContainerType({
-  currentVersion: new ByteVectorType(4),
-  genesisValidatorsRoot: new ByteVectorType(32),
-});
-
-const SigningRootType = new ContainerType({
-  objectRoot: new ByteVectorType(32),
-  domain: new ByteVectorType(32),
-});
-
-/**
- * https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#compute_fork_data_root
- * @param currentVersion - Uint8Array of the current fork version.
- * @param genesisValidatorsRoot - Uint8Array of the genesis validators root.
- * @returns Uint8Array - The 32-byte fork data root.
- */
-function computeForkDataRoot(
-  currentVersion: Uint8Array,
-  genesisValidatorsRoot: Uint8Array,
-): Uint8Array {
-  const forkDataVal = ForkDataType.defaultValue();
-  forkDataVal.currentVersion = currentVersion;
-  forkDataVal.genesisValidatorsRoot = genesisValidatorsRoot;
-  return Buffer.from(ForkDataType.hashTreeRoot(forkDataVal).buffer);
-}
-
-/**
- * Computes the domain for a given domain type, fork version, and genesis state.
- * https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#compute_domain
- * @param domainType - Uint8Array representing the domain type (e.g., DOMAIN_VOLUNTARY_EXIT).
- * @param forkVersionString - Hex string of the fork version (e.g., Capella fork version).
- * @param genesisValidatorsRootOverride - Optional Uint8Array to override the default genesis validators root.
- * @returns Uint8Array - The 32-byte domain.
- */
-export function computeDomain(
-  domainType: Uint8Array, // Should be 4 bytes
-  forkVersionString: string, // Hex string, e.g., '0x03000000'
-  genesisValidatorsRootOverride?: Uint8Array, // 32 bytes
-): Uint8Array {
-  const forkVersionBytes = fromHexString(
-    forkVersionString.substring(2, forkVersionString.length),
-  );
-
-  if (forkVersionBytes.length !== 4) {
-    throw new Error('Fork version must be 4 bytes');
-  }
-  if (domainType.length !== 4) {
-    throw new Error('Domain type must be 4 bytes');
-  }
-
-  const actualGenesisValidatorsRoot =
-    genesisValidatorsRootOverride ??
-    fromHexString(GENESIS_VALIDATOR_ROOT_HEX_STRING.substring(2));
-
-  if (actualGenesisValidatorsRoot.length !== 32) {
-    throw new Error('genesisValidatorsRoot must be 32 bytes');
-  }
-  const forkDataRoot = computeForkDataRoot(
-    forkVersionBytes,
-    actualGenesisValidatorsRoot,
-  );
-  const domain = new Uint8Array(32);
-  domain.set(domainType);
-  domain.set(forkDataRoot.subarray(0, 28), 4); // Set the remaining 28 bytes from forkDataRoot
-  return domain;
-}
-
-/**
- * Computes the signing root for an SSZ object and a domain.
- * https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#compute_signing_root
- * @param sszObjectRoot - Uint8Array of the hash tree root of the SSZ object.
- * @param domain - Uint8Array of the domain.
- * @returns Uint8Array - The 32-byte signing root.
- */
-function computeSigningRoot(
-  sszObjectRoot: Uint8Array, // Should be 32 bytes
-  domain: Uint8Array, // Should be 32 bytes
-): Uint8Array {
-  if (sszObjectRoot.length !== 32) {
-    throw new Error('SSZ object root must be 32 bytes');
-  }
-  if (domain.length !== 32) {
-    throw new Error('Domain must be 32 bytes');
-  }
-
-  const val = SigningRootType.defaultValue();
-  val.objectRoot = sszObjectRoot;
-  val.domain = domain;
-  return Buffer.from(SigningRootType.hashTreeRoot(val).buffer);
-}
-
-/**
- * Convenience wrapper for computeSigningRoot.
- * @param domain - Uint8Array of the domain.
- * @param messageBuffer - Buffer of the message (SSZ object root).
- * @returns Uint8Array - The signing root.
- */
-export function signingRoot(
-  domain: Uint8Array,
-  messageBuffer: Buffer, // Assumed to be the 32-byte sszObjectRoot
-): Uint8Array {
-  const sszObjectRootU8 = Uint8Array.from(messageBuffer);
-  return computeSigningRoot(sszObjectRootU8, domain);
-}

package/src/incentives/incentiveHelpers.ts

@@ -1,55 +0,0 @@
-import { type ProviderType, type SignerType, type ETH_ADDRESS } from '../types';
-import { Contract } from 'ethers';
-import { MerkleDistributorABI } from '../abi/MerkleDistributorWithDeadline';
-
-export const claimIncentivesFromMerkleDistributor = async (incentivesData: {
-  signer: SignerType;
-  contractAddress: ETH_ADDRESS;
-  index: number;
-  operatorAddress: ETH_ADDRESS;
-  amount: string;
-  merkleProof: string[];
-}): Promise<{ txHash: string }> => {
-  try {
-    const contract = new Contract(
-      incentivesData.contractAddress,
-      MerkleDistributorABI.abi,
-      incentivesData.signer,
-    );
-
-    const tx = await contract.claim(
-      BigInt(incentivesData.index),
-      incentivesData.operatorAddress,
-      BigInt(incentivesData.amount),
-      incentivesData.merkleProof,
-    );
-
-    const receipt = await tx.wait();
-
-    return { txHash: receipt.hash };
-  } catch (error: any) {
-    console.log('Error claiming incentives:', error);
-    throw new Error(`Failed to claim incentives: ${error.message}`);
-  }
-};
-
-export const isClaimedFromMerkleDistributor = async (
-  contractAddress: ETH_ADDRESS,
-  index: number,
-  provider: ProviderType | undefined | null,
-): Promise<boolean> => {
-  try {
-    const contract = new Contract(
-      contractAddress,
-      MerkleDistributorABI.abi,
-      provider,
-    );
-
-    const claimed = await contract.isClaimed(BigInt(index));
-
-    return claimed;
-  } catch (error: any) {
-    console.log('Error checking claim status:', error);
-    throw new Error(`Failed to check claim status: ${error.message}`);
-  }
-};

package/src/incentives/incentives.ts

@@ -1,153 +0,0 @@
-import { isContractAvailable } from '../utils';
-import {
-  type ClaimableIncentives,
-  type ETH_ADDRESS,
-  FORK_NAMES,
-  type ProviderType,
-  type SignerType,
-  type ClaimIncentivesResponse,
-} from '../types';
-import {
-  claimIncentivesFromMerkleDistributor,
-  isClaimedFromMerkleDistributor,
-} from './incentiveHelpers';
-import { DEFAULT_BASE_VERSION } from '../constants';
-
-/**
- * Incentives can be used for fetching and claiming Obol incentives.
- * @class
- * @internal Access it through Client.incentives.
- * @example
- * const obolClient = new Client(config);
- * await obolClient.incentives.claimIncentives(address);
- */
-export class Incentives {
-  private readonly signer: SignerType | undefined;
-  public readonly chainId: number;
-  private readonly request: (
-    endpoint: string,
-    options?: RequestInit,
-  ) => Promise<any>;
-
-  public readonly provider: ProviderType | undefined | null;
-
-  constructor(
-    signer: SignerType | undefined,
-    chainId: number,
-    request: (endpoint: string, options?: RequestInit) => Promise<any>,
-    provider: ProviderType | undefined | null,
-  ) {
-    this.signer = signer;
-    this.chainId = chainId;
-    this.request = request;
-    this.provider = provider;
-  }
-
-  /**
-   * Claims Obol incentives from a Merkle Distributor contract using an address.
-   *
-   * This method automatically fetches incentive data and verifies whether the incentives have already been claimed.
-   * If `txHash` is `null`, it indicates that the incentives were already claimed.
-   *
-   * Note: This method is not yet enabled and will throw an error if called.
-   *
-   * @remarks
-   * **⚠️ Important:**  If you're storing the private key in an `.env` file, ensure it is securely managed
-   * and not pushed to version control.
-   *
-   * @param {string} address - The address to claim incentives for
-   * @returns {Promise<ClaimIncentivesResponse>} The transaction hash or already claimed status
-   * @throws Will throw an error if the incentives data is not found or the claim fails
-   *
-   * An example of how to use claimIncentives:
-   * [obolClient](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L281)
-   */
-  async claimIncentives(address: string): Promise<ClaimIncentivesResponse> {
-    if (!this.signer) {
-      throw new Error('Signer is required in claimIncentives');
-    }
-
-    try {
-      const incentivesData = await this.getIncentivesByAddress(address);
-
-      if (!incentivesData?.contract_address) {
-        throw new Error(`No incentives found for address ${address}`);
-      }
-
-      const isContractDeployed = await isContractAvailable(
-        incentivesData.contract_address,
-        this.provider as ProviderType,
-      );
-
-      if (!isContractDeployed) {
-        throw new Error(
-          `Merkle Distributor contract is not available at address ${incentivesData.contract_address}`,
-        );
-      }
-
-      const claimed = await this.isClaimed(
-        incentivesData.contract_address,
-        incentivesData.index,
-      );
-
-      if (claimed) {
-        return { txHash: null };
-      }
-
-      const { txHash } = await claimIncentivesFromMerkleDistributor({
-        signer: this.signer,
-        contractAddress: incentivesData.contract_address,
-        index: incentivesData.index,
-        operatorAddress: incentivesData.operator_address,
-        amount: incentivesData.amount,
-        merkleProof: incentivesData.merkle_proof,
-      });
-
-      return { txHash };
-    } catch (error: any) {
-      console.log('Error claiming incentives:', error);
-      throw new Error(`Failed to claim incentives: ${error.message}`);
-    }
-  }
-
-  /**
-   * Read isClaimed.
-   *
-   * @param {ETH_ADDRESS} contractAddress - Address of the Merkle Distributor Contract
-   * @param {ETH_ADDRESS} index - operator index in merkle tree
-   * @returns {Promise<boolean>} true if incentives are already claime
-   *
-   *
-   * An example of how to use isClaimed:
-   * [obolClient](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L266)
-   */
-  async isClaimed(
-    contractAddress: ETH_ADDRESS,
-    index: number,
-  ): Promise<boolean> {
-    return await isClaimedFromMerkleDistributor(
-      contractAddress,
-      index,
-      this.provider,
-    );
-  }
-
-  /**
-   * @param address - Operator address
-   * @returns {Promise<IncentivesType>} The matched incentives from DB
-   * @throws On not found if address not found.
-   *
-   * An example of how to use getIncentivesByAddress:
-   * [obolClient](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L250)
-   */
-  async getIncentivesByAddress(address: string): Promise<ClaimableIncentives> {
-    const network = FORK_NAMES[this.chainId];
-    const incentives: ClaimableIncentives = await this.request(
-      `/${DEFAULT_BASE_VERSION}/address/incentives/${network}/${address}`,
-      {
-        method: 'GET',
-      },
-    );
-    return incentives;
-  }
-}