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

package/dist/esm/src/incentives/incentives.js

@@ -1,115 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { isContractAvailable } from '../utils';
-import { FORK_NAMES, } 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 {
-    constructor(signer, chainId, request, provider) {
-        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)
-     */
-    claimIncentives(address) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer) {
-                throw new Error('Signer is required in claimIncentives');
-            }
-            try {
-                const incentivesData = yield this.getIncentivesByAddress(address);
-                if (!(incentivesData === null || incentivesData === void 0 ? void 0 : incentivesData.contract_address)) {
-                    throw new Error(`No incentives found for address ${address}`);
-                }
-                const isContractDeployed = yield isContractAvailable(incentivesData.contract_address, this.provider);
-                if (!isContractDeployed) {
-                    throw new Error(`Merkle Distributor contract is not available at address ${incentivesData.contract_address}`);
-                }
-                const claimed = yield this.isClaimed(incentivesData.contract_address, incentivesData.index);
-                if (claimed) {
-                    return { txHash: null };
-                }
-                const { txHash } = yield 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) {
-                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)
-     */
-    isClaimed(contractAddress, index) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield 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)
-     */
-    getIncentivesByAddress(address) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const network = FORK_NAMES[this.chainId];
-            const incentives = yield this.request(`/${DEFAULT_BASE_VERSION}/address/incentives/${network}/${address}`, {
-                method: 'GET',
-            });
-            return incentives;
-        });
-    }
-}

package/dist/esm/src/schema.js

@@ -1,349 +0,0 @@
-import { ZeroAddress } from 'ethers';
-import { DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT, DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT, PRINCIPAL_THRESHOLD, } from './constants';
-import { VALID_DEPOSIT_AMOUNTS, VALID_NON_COMPOUNDING_AMOUNTS } from './ajv';
-export const operatorPayloadSchema = {
-    type: 'object',
-    properties: {
-        version: { type: 'string' },
-        enr: { type: 'string' },
-    },
-    required: ['version', 'enr'],
-};
-export const definitionSchema = {
-    type: 'object',
-    properties: {
-        name: { type: 'string' },
-        operators: {
-            type: 'array',
-            minItems: 4,
-            items: {
-                type: 'object',
-                properties: {
-                    address: {
-                        type: 'string',
-                    },
-                },
-                required: ['address'],
-            },
-            validateUniqueAddresses: true,
-        },
-        validators: {
-            type: 'array',
-            minItems: 1,
-            items: {
-                type: 'object',
-                properties: {
-                    fee_recipient_address: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{40}$',
-                    },
-                    withdrawal_address: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{40}$',
-                    },
-                },
-                required: ['fee_recipient_address', 'withdrawal_address'],
-            },
-        },
-        deposit_amounts: {
-            type: ['array', 'null'],
-            items: {
-                type: 'string',
-                pattern: '^[0-9]+$',
-            },
-            if: {
-                $data: '1/compounding',
-            },
-            then: {
-                items: {
-                    enum: VALID_DEPOSIT_AMOUNTS,
-                },
-            },
-            else: {
-                items: {
-                    enum: VALID_NON_COMPOUNDING_AMOUNTS,
-                },
-            },
-            default: null,
-        },
-        compounding: {
-            type: 'boolean',
-            default: false,
-        },
-        target_gas_limit: {
-            type: 'number',
-            minimum: 1,
-            default: 36000000,
-        },
-        consensus_protocol: {
-            type: 'string',
-            enum: ['qbft', ''],
-            default: '',
-        },
-    },
-    required: ['name', 'operators', 'validators'],
-};
-export const totalSplitterPayloadSchema = {
-    type: 'object',
-    properties: {
-        splitRecipients: {
-            type: 'array',
-            items: {
-                type: 'object',
-                properties: {
-                    account: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{40}$',
-                    },
-                    percentAllocation: { type: 'number' },
-                },
-                required: ['account', 'percentAllocation'],
-            },
-        },
-        ObolRAFSplit: {
-            type: 'number',
-            minimum: DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT,
-            default: DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT,
-        },
-        distributorFee: {
-            type: 'number',
-            maximum: 10,
-            multipleOf: 0.01,
-            default: 0,
-        },
-        controllerAddress: {
-            type: 'string',
-            pattern: '^0x[a-fA-F0-9]{40}$',
-            default: ZeroAddress,
-        },
-    },
-    validateTotalSplitRecipients: true,
-    required: ['splitRecipients'],
-};
-export const rewardsSplitterPayloadSchema = {
-    type: 'object',
-    properties: Object.assign(Object.assign({}, totalSplitterPayloadSchema.properties), { ObolRAFSplit: {
-            type: 'number',
-            minimum: DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
-            default: DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
-        }, recoveryAddress: {
-            type: 'string',
-            pattern: '^0x[a-fA-F0-9]{40}$',
-            default: ZeroAddress,
-        }, etherAmount: { type: 'number' }, principalRecipient: {
-            type: 'string',
-            pattern: '^0x[a-fA-F0-9]{40}$',
-        } }),
-    validateRewardsSplitRecipients: true,
-    required: ['splitRecipients', 'principalRecipient', 'etherAmount'],
-};
-export const ovmBaseSplitPayload = {
-    rewardSplitRecipients: {
-        type: 'array',
-        items: {
-            type: 'object',
-            properties: {
-                address: {
-                    type: 'string',
-                    pattern: '^0x[a-fA-F0-9]{40}$',
-                },
-                percentAllocation: { type: 'number' },
-            },
-            required: ['address', 'percentAllocation'],
-        },
-    },
-    OVMOwnerAddress: {
-        type: 'string',
-        pattern: '^0x[a-fA-F0-9]{40}$',
-    },
-    splitOwnerAddress: {
-        type: 'string',
-        pattern: '^0x[a-fA-F0-9]{40}$',
-        default: ZeroAddress,
-    },
-    principalThreshold: {
-        type: 'number',
-        minimum: 16,
-        default: PRINCIPAL_THRESHOLD,
-    },
-    distributorFeePercent: {
-        type: 'number',
-        minimum: 0,
-        maximum: 10,
-        default: 0,
-    },
-};
-export const ovmRewardsSplitPayloadSchema = {
-    type: 'object',
-    properties: Object.assign(Object.assign({}, ovmBaseSplitPayload), { principalRecipient: {
-            type: 'string',
-            pattern: '^0x[a-fA-F0-9]{40}$',
-        } }),
-    validateOVMRewardsSplitRecipients: true,
-    required: ['rewardSplitRecipients', 'OVMOwnerAddress', 'principalRecipient'],
-};
-export const ovmTotalSplitPayloadSchema = {
-    type: 'object',
-    properties: Object.assign(Object.assign({}, ovmBaseSplitPayload), { principalSplitRecipients: {
-            type: 'array',
-            items: {
-                type: 'object',
-                properties: {
-                    address: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{40}$',
-                    },
-                    percentAllocation: { type: 'number' },
-                },
-                required: ['address', 'percentAllocation'],
-            },
-        } }),
-    validateOVMRewardsSplitRecipients: true,
-    validateOVMTotalSplitRecipients: true,
-    required: [
-        'rewardSplitRecipients',
-        'principalSplitRecipients',
-        'OVMOwnerAddress',
-    ],
-};
-export const ovmRequestWithdrawalPayloadSchema = {
-    type: 'object',
-    properties: {
-        withdrawalFees: {
-            type: 'string',
-            pattern: '^[0-9]+$',
-        },
-        ovmAddress: {
-            type: 'string',
-            pattern: '^0x[a-fA-F0-9]{40}$',
-        },
-        pubKeys: {
-            type: 'array',
-            minItems: 1,
-            items: {
-                type: 'string',
-                pattern: '^0x[a-fA-F0-9]{96}$', // 48 bytes = 96 hex chars + 0x prefix
-            },
-        },
-        amounts: {
-            type: 'array',
-            minItems: 1,
-            items: {
-                type: 'string',
-                pattern: '^[0-9]+$',
-            },
-        },
-    },
-    validateOVMRequestWithdrawalPayload: true,
-    required: ['ovmAddress', 'pubKeys', 'amounts', 'withdrawalFees'],
-};
-export const eoaWithdrawalPayloadSchema = {
-    type: 'object',
-    properties: {
-        pubkey: {
-            type: 'string',
-            pattern: '^0x[a-fA-F0-9]{96}$', // 48 bytes = 96 hex chars + 0x prefix
-        },
-        allocation: {
-            type: 'number',
-            minimum: 0,
-        },
-        requiredFee: {
-            type: 'string',
-            pattern: '^[0-9]+$',
-        },
-    },
-    required: ['pubkey', 'allocation', 'requiredFee'],
-};
-export const ovmDepositPayloadSchema = {
-    type: 'object',
-    properties: {
-        ovmAddress: {
-            type: 'string',
-            pattern: '^0x[a-fA-F0-9]{40}$',
-        },
-        deposits: {
-            type: 'array',
-            minItems: 1,
-            items: {
-                type: 'object',
-                properties: {
-                    pubkey: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{96}$',
-                    },
-                    withdrawal_credentials: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{64}$',
-                        description: '32 bytes withdrawal credentials',
-                    },
-                    signature: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{192}$',
-                        description: '96 bytes signature (190 hex chars + 0x prefix)',
-                    },
-                    deposit_data_root: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{64}$', // 32 bytes = 64 hex chars + 0x prefix
-                    },
-                    amount: {
-                        type: 'string',
-                        pattern: '^[0-9]+$',
-                    },
-                },
-                required: [
-                    'pubkey',
-                    'withdrawal_credentials',
-                    'signature',
-                    'deposit_data_root',
-                    'amount',
-                ],
-            },
-        },
-    },
-    required: ['ovmAddress', 'deposits'],
-};
-export const eoaDepositPayloadSchema = {
-    type: 'object',
-    properties: {
-        deposits: {
-            type: 'array',
-            minItems: 1,
-            items: {
-                type: 'object',
-                properties: {
-                    pubkey: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{96}$',
-                    },
-                    withdrawal_credentials: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{64}$',
-                        description: '32 bytes withdrawal credentials',
-                    },
-                    signature: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{192}$',
-                        description: '96 bytes signature (190 hex chars + 0x prefix)',
-                    },
-                    deposit_data_root: {
-                        type: 'string',
-                        pattern: '^0x[a-fA-F0-9]{64}$', // 32 bytes = 64 hex chars + 0x prefix
-                    },
-                    amount: {
-                        type: 'string',
-                        pattern: '^[0-9]+$',
-                    },
-                },
-                required: [
-                    'pubkey',
-                    'withdrawal_credentials',
-                    'signature',
-                    'deposit_data_root',
-                    'amount',
-                ],
-            },
-        },
-    },
-    required: ['deposits'],
-};

package/dist/esm/src/services.js

@@ -1,29 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { isValidClusterLock } from './verification/common.js';
-/**
- * Verifies Cluster Lock's validity.
- * @param lock - cluster lock
- * @param safeRpcUrl - optional safeRpcUrl for safe wallet verification
- * @returns {Promise<{ result: boolean }> } boolean result to indicate if lock is valid
- * @throws on missing keys or values.
- *
- * An example of how to use validateClusterLock:
- * [validateClusterLock](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L127)
- */
-export const validateClusterLock = (lock, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const isLockValid = yield isValidClusterLock(lock, safeRpcUrl);
-        return isLockValid;
-    }
-    catch (err) {
-        throw err;
-    }
-});