@obolnetwork/obol-sdk 2.2.1 → 2.2.3

package/README.md

@@ -17,6 +17,11 @@ If you're integrating this SDK with a **backend** (e.g., in Node.js), and you st
 - The private key is securely stored (e.g., in an `.env` file).
 - Never commit or push your `.env` file containing the private key to version control.
 
+## ⚡️ Integration with Safe Wallet
+
+When integrating the Obol SDK with a **Safe Wallet**, you will need to provide the `RPC_MAINNET` or `RPC_HOLESKY` or `RPC_GNOSIS` or `RPC_SEPOLIA` environment variable, pointing to the correct network's RPC URL. This is required to interact with Safe kit.
+
+
 ## Contributing
 
 Please review the following guidelines:

package/dist/cjs/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "2.2.1",
+    "version": "2.2.3",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"

package/dist/cjs/src/index.js

@@ -37,6 +37,7 @@ const utils_js_1 = require("./utils.js");
 __exportStar(require("./types.js"), exports);
 __exportStar(require("./services.js"), exports);
 __exportStar(require("./verification/signature-validator.js"), exports);
+__exportStar(require("./verification/common.js"), exports);
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
  */

package/dist/cjs/src/utils.js

@@ -69,7 +69,7 @@ const isContractAvailable = (contractAddress, provider, bytecode) => __awaiter(v
 exports.isContractAvailable = isContractAvailable;
 const getProvider = (chainId) => {
     const rpcUrl = constants_1.PROVIDER_MAP[chainId];
-    if (!rpcUrl) {
+    if (!rpcUrl || rpcUrl === 'undefined') {
         throw new Error(`No provider configured for ${types_1.FORK_NAMES[chainId]}`);
     }
     return new ethers_1.ethers.JsonRpcProvider(rpcUrl);

package/dist/cjs/src/verification/common.js

@@ -49,6 +49,7 @@ const utils_js_1 = require("../utils.js");
 const discv5_1 = require("@chainsafe/discv5");
 const v1_8_0_js_1 = require("./v1.8.0.js");
 const signature_validator_js_1 = require("./signature-validator.js");
+const v1_10_0_js_1 = require("./v1.10.0.js");
 // cluster-definition hash
 /**
  * @param cluster The cluster configuration or the cluster definition
@@ -75,6 +76,13 @@ const clusterConfigOrDefinitionHash = (cluster, configOnly) => {
         return ('0x' +
             Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex'));
     }
+    if (semver.eq(cluster.version, 'v1.10.0')) {
+        definitionType = (0, v1_10_0_js_1.clusterDefinitionContainerTypeV1X10)(configOnly);
+        val = (0, v1_10_0_js_1.hashClusterDefinitionV1X10)(cluster, configOnly);
+        const x = '0x' +
+            Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex');
+        return x;
+    }
     throw new Error('unsupported version');
 };
 exports.clusterConfigOrDefinitionHash = clusterConfigOrDefinitionHash;
@@ -102,6 +110,21 @@ const clusterLockHash = (clusterLock) => {
         }
         return (0, v1_8_0_js_1.hashClusterLockV1X8)(clusterLock);
     }
+    if (semver.eq(clusterLock.cluster_definition.version, 'v1.10.0')) {
+        // if (
+        //   clusterLock.cluster_definition.deposit_amounts === null &&
+        //   clusterLock.distributed_validators.some(
+        //     distributedValidator =>
+        //       distributedValidator.partial_deposit_data?.length !== 1 ||
+        //       distributedValidator.partial_deposit_data[0].amount !== '32000000000',
+        //   )
+        // ) {
+        //   throw new Error(
+        //     'mismatch between deposit_amounts and partial_deposit_data fields',
+        //   );
+        // }
+        return (0, v1_10_0_js_1.hashClusterLockV1X10)(clusterLock);
+    }
     // other versions
     throw new Error('unsupported version');
 };
@@ -219,10 +242,15 @@ const computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = (0,
 const verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, forkVersion) => {
     const depositDomain = computeDomain((0, ssz_1.fromHexString)(constants_js_1.DOMAIN_DEPOSIT), forkVersion);
     const eth1AddressWithdrawalPrefix = '0x01';
+    const compoundingWithdrawalPrefix = '0x02';
     if (eth1AddressWithdrawalPrefix +
         '0'.repeat(22) +
         withdrawalAddress.toLowerCase().slice(2) !==
-        depositData.withdrawal_credentials) {
+        depositData.withdrawal_credentials &&
+        compoundingWithdrawalPrefix +
+            '0'.repeat(22) +
+            withdrawalAddress.toLowerCase().slice(2) !==
+            depositData.withdrawal_credentials) {
         return { isValidDepositData: false, depositDataMsg: new Uint8Array(0) };
     }
     if (distributedPublicKey !== depositData.pubkey) {
@@ -294,6 +322,9 @@ const verifyLockData = (clusterLock) => __awaiter(void 0, void 0, void 0, functi
     if (semver.eq(clusterLock.cluster_definition.version, 'v1.8.0')) {
         return (0, v1_8_0_js_1.verifyDVV1X8)(clusterLock);
     }
+    if (semver.eq(clusterLock.cluster_definition.version, 'v1.10.0')) {
+        return (0, v1_10_0_js_1.verifyDVV1X10)(clusterLock);
+    }
     return false;
 });
 const isValidClusterLock = (clusterLock) => __awaiter(void 0, void 0, void 0, function* () {

package/dist/cjs/src/verification/v1.10.0.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyDVV1X10 = exports.hashClusterLockV1X10 = exports.hashClusterDefinitionV1X10 = exports.clusterDefinitionContainerTypeV1X10 = void 0;
+const uint_1 = require("@chainsafe/ssz/lib/type/uint");
+const utils_1 = require("../utils");
+const sszTypes_1 = require("./sszTypes");
+const ssz_1 = require("@chainsafe/ssz");
+const v1_8_0_1 = require("./v1.8.0");
+/**
+ * Returns the containerized cluster definition
+ * @param cluster ClusterDefinition to calculate the type from
+ * @returns SSZ Containerized type of cluster input
+ */
+const clusterDefinitionContainerTypeV1X10 = (configOnly) => {
+    let returnedContainerType = {
+        uuid: new ssz_1.ByteListType(64),
+        name: new ssz_1.ByteListType(256),
+        version: new ssz_1.ByteListType(16),
+        timestamp: new ssz_1.ByteListType(32),
+        num_validators: new uint_1.UintNumberType(8),
+        threshold: new uint_1.UintNumberType(8),
+        dkg_algorithm: new ssz_1.ByteListType(32),
+        fork_version: new ssz_1.ByteVectorType(4),
+        operators: new ssz_1.ListCompositeType((0, sszTypes_1.newOperatorContainerType)(configOnly), 256),
+        creator: (0, sszTypes_1.newCreatorContainerType)(configOnly),
+        validators: new ssz_1.ListCompositeType(sszTypes_1.validatorsContainerType, 65536),
+        deposit_amounts: new ssz_1.ListBasicType(new uint_1.UintNumberType(8), 256),
+        consensus_protocol: new ssz_1.ByteListType(256),
+        target_gas_limit: new uint_1.UintNumberType(8),
+    };
+    if (!configOnly) {
+        returnedContainerType = Object.assign(Object.assign({}, returnedContainerType), { config_hash: new ssz_1.ByteVectorType(32) });
+    }
+    return new ssz_1.ContainerType(returnedContainerType);
+};
+exports.clusterDefinitionContainerTypeV1X10 = clusterDefinitionContainerTypeV1X10;
+const hashClusterDefinitionV1X10 = (cluster, configOnly) => {
+    const definitionType = (0, exports.clusterDefinitionContainerTypeV1X10)(configOnly);
+    const val = definitionType.defaultValue();
+    // order should be same as charon https://github.com/ObolNetwork/charon/blob/main/cluster/ssz.go#L276
+    val.uuid = (0, utils_1.strToUint8Array)(cluster.uuid);
+    val.name = (0, utils_1.strToUint8Array)(cluster.name);
+    val.version = (0, utils_1.strToUint8Array)(cluster.version);
+    val.timestamp = (0, utils_1.strToUint8Array)(cluster.timestamp);
+    val.num_validators = cluster.num_validators;
+    val.threshold = cluster.threshold;
+    val.dkg_algorithm = (0, utils_1.strToUint8Array)(cluster.dkg_algorithm);
+    val.fork_version = (0, ssz_1.fromHexString)(cluster.fork_version);
+    val.operators = cluster.operators.map(operator => {
+        return configOnly
+            ? { address: (0, ssz_1.fromHexString)(operator.address) }
+            : {
+                address: (0, ssz_1.fromHexString)(operator.address),
+                enr: (0, utils_1.strToUint8Array)(operator.enr),
+                config_signature: (0, ssz_1.fromHexString)(operator.config_signature),
+                enr_signature: (0, ssz_1.fromHexString)(operator.enr_signature),
+            };
+    });
+    val.creator = configOnly
+        ? { address: (0, ssz_1.fromHexString)(cluster.creator.address) }
+        : {
+            address: (0, ssz_1.fromHexString)(cluster.creator.address),
+            config_signature: (0, ssz_1.fromHexString)(cluster.creator.config_signature),
+        };
+    val.validators = cluster.validators.map(validator => {
+        return {
+            fee_recipient_address: (0, ssz_1.fromHexString)(validator.fee_recipient_address),
+            withdrawal_address: (0, ssz_1.fromHexString)(validator.withdrawal_address),
+        };
+    });
+    if (cluster.deposit_amounts) {
+        val.deposit_amounts = cluster.deposit_amounts.map((amount) => {
+            return parseInt(amount);
+        });
+    }
+    if (cluster.consensus_protocol) {
+        val.consensus_protocol = (0, utils_1.strToUint8Array)(cluster.consensus_protocol);
+    }
+    if (cluster.target_gas_limit) {
+        val.target_gas_limit = cluster.target_gas_limit;
+    }
+    if (!configOnly) {
+        val.config_hash = (0, ssz_1.fromHexString)(cluster.config_hash);
+    }
+    return val;
+};
+exports.hashClusterDefinitionV1X10 = hashClusterDefinitionV1X10;
+// cluster lock
+const dvContainerTypeV1X10 = new ssz_1.ContainerType({
+    distributed_public_key: new ssz_1.ByteVectorType(48),
+    public_shares: new ssz_1.ListCompositeType(new ssz_1.ByteVectorType(48), 256),
+    partial_deposit_data: new ssz_1.ListCompositeType(sszTypes_1.depositDataContainer, 256),
+    builder_registration: sszTypes_1.builderRegistrationContainer,
+});
+/**
+ * @returns SSZ Containerized type of cluster lock
+ */
+const clusterLockContainerTypeV1X10 = () => {
+    return new ssz_1.ContainerType({
+        cluster_definition: (0, exports.clusterDefinitionContainerTypeV1X10)(false),
+        distributed_validators: new ssz_1.ListCompositeType(dvContainerTypeV1X10, 65536),
+    });
+};
+/**
+ * @param cluster The published cluster lock
+ * @returns The lock hash in of the corresponding cluster
+ */
+const hashClusterLockV1X10 = (cluster) => {
+    const lockType = clusterLockContainerTypeV1X10();
+    const val = lockType.defaultValue();
+    // Check if we can replace with definition_hash
+    val.cluster_definition = (0, exports.hashClusterDefinitionV1X10)(cluster.cluster_definition, false);
+    val.distributed_validators = cluster.distributed_validators.map(dValidator => {
+        var _a, _b, _c, _d, _e;
+        return {
+            distributed_public_key: (0, ssz_1.fromHexString)(dValidator.distributed_public_key),
+            public_shares: dValidator.public_shares.map(publicShare => (0, ssz_1.fromHexString)(publicShare)),
+            // should be fixed
+            partial_deposit_data: dValidator.partial_deposit_data.map(depositData => {
+                return {
+                    pubkey: (0, ssz_1.fromHexString)(depositData.pubkey),
+                    withdrawal_credentials: (0, ssz_1.fromHexString)(depositData.withdrawal_credentials),
+                    amount: parseInt(depositData.amount),
+                    signature: (0, ssz_1.fromHexString)(depositData.signature),
+                };
+            }),
+            builder_registration: {
+                message: {
+                    fee_recipient: (0, ssz_1.fromHexString)((_a = dValidator.builder_registration) === null || _a === void 0 ? void 0 : _a.message.fee_recipient),
+                    gas_limit: (_b = dValidator.builder_registration) === null || _b === void 0 ? void 0 : _b.message.gas_limit,
+                    timestamp: (_c = dValidator.builder_registration) === null || _c === void 0 ? void 0 : _c.message.timestamp,
+                    pubkey: (0, ssz_1.fromHexString)((_d = dValidator.builder_registration) === null || _d === void 0 ? void 0 : _d.message.pubkey),
+                },
+                signature: (0, ssz_1.fromHexString)((_e = dValidator.builder_registration) === null || _e === void 0 ? void 0 : _e.signature),
+            },
+        };
+    });
+    return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex');
+};
+exports.hashClusterLockV1X10 = hashClusterLockV1X10;
+// DV verification
+exports.verifyDVV1X10 = v1_8_0_1.verifyDVV1X8;