@ssv-labs/ssv-sdk 0.0.4 → 0.0.5

package/dist/config/chains.d.ts

@@ -165,6 +165,7 @@ export declare const chains: {
     };
 };
 export declare const chainIds: (1 | 560048 | 17000)[];
+export declare const networks: ("Hoodi" | "Ethereum" | "Holesky")[];
 export type SupportedChainsIDs = (typeof chainIds)[number];
 export declare const graph_endpoints: Record<SupportedChainsIDs, string>;
 export declare const rest_endpoints: Record<SupportedChainsIDs, string>;

package/dist/{config-DlwfpwZd.mjs → globals-DsbufPrE.mjs}

@@ -1,4 +1,166 @@
-import { formatUnits, decodeAbiParameters, parseUnits, isAddress } from "viem";
+import { formatUnits, decodeAbiParameters, defineChain as defineChain$1, parseUnits, isAddress } from "viem";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var browser = { exports: {} };
+var process = browser.exports = {};
+var cachedSetTimeout;
+var cachedClearTimeout;
+function defaultSetTimout() {
+  throw new Error("setTimeout has not been defined");
+}
+function defaultClearTimeout() {
+  throw new Error("clearTimeout has not been defined");
+}
+(function() {
+  try {
+    if (typeof setTimeout === "function") {
+      cachedSetTimeout = setTimeout;
+    } else {
+      cachedSetTimeout = defaultSetTimout;
+    }
+  } catch (e) {
+    cachedSetTimeout = defaultSetTimout;
+  }
+  try {
+    if (typeof clearTimeout === "function") {
+      cachedClearTimeout = clearTimeout;
+    } else {
+      cachedClearTimeout = defaultClearTimeout;
+    }
+  } catch (e) {
+    cachedClearTimeout = defaultClearTimeout;
+  }
+})();
+function runTimeout(fun) {
+  if (cachedSetTimeout === setTimeout) {
+    return setTimeout(fun, 0);
+  }
+  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+    cachedSetTimeout = setTimeout;
+    return setTimeout(fun, 0);
+  }
+  try {
+    return cachedSetTimeout(fun, 0);
+  } catch (e) {
+    try {
+      return cachedSetTimeout.call(null, fun, 0);
+    } catch (e2) {
+      return cachedSetTimeout.call(this, fun, 0);
+    }
+  }
+}
+function runClearTimeout(marker) {
+  if (cachedClearTimeout === clearTimeout) {
+    return clearTimeout(marker);
+  }
+  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+    cachedClearTimeout = clearTimeout;
+    return clearTimeout(marker);
+  }
+  try {
+    return cachedClearTimeout(marker);
+  } catch (e) {
+    try {
+      return cachedClearTimeout.call(null, marker);
+    } catch (e2) {
+      return cachedClearTimeout.call(this, marker);
+    }
+  }
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+function cleanUpNextTick() {
+  if (!draining || !currentQueue) {
+    return;
+  }
+  draining = false;
+  if (currentQueue.length) {
+    queue = currentQueue.concat(queue);
+  } else {
+    queueIndex = -1;
+  }
+  if (queue.length) {
+    drainQueue();
+  }
+}
+function drainQueue() {
+  if (draining) {
+    return;
+  }
+  var timeout = runTimeout(cleanUpNextTick);
+  draining = true;
+  var len = queue.length;
+  while (len) {
+    currentQueue = queue;
+    queue = [];
+    while (++queueIndex < len) {
+      if (currentQueue) {
+        currentQueue[queueIndex].run();
+      }
+    }
+    queueIndex = -1;
+    len = queue.length;
+  }
+  currentQueue = null;
+  draining = false;
+  runClearTimeout(timeout);
+}
+process.nextTick = function(fun) {
+  var args = new Array(arguments.length - 1);
+  if (arguments.length > 1) {
+    for (var i = 1; i < arguments.length; i++) {
+      args[i - 1] = arguments[i];
+    }
+  }
+  queue.push(new Item(fun, args));
+  if (queue.length === 1 && !draining) {
+    runTimeout(drainQueue);
+  }
+};
+function Item(fun, array) {
+  this.fun = fun;
+  this.array = array;
+}
+Item.prototype.run = function() {
+  this.fun.apply(null, this.array);
+};
+process.title = "browser";
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = "";
+process.versions = {};
+function noop() {
+}
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+process.listeners = function(name) {
+  return [];
+};
+process.binding = function(name) {
+  throw new Error("process.binding is not supported");
+};
+process.cwd = function() {
+  return "/";
+};
+process.chdir = function(dir) {
+  throw new Error("process.chdir is not supported");
+};
+process.umask = function() {
+  return 0;
+};
+var browserExports = browser.exports;
+const process$1 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
 const numberFormatter = new Intl.NumberFormat("en-US", {
   useGrouping: true,
   maximumFractionDigits: 2
@@ -44,6 +206,125 @@ const getOperatorIds = (operators) => {
 const decodeOperatorPublicKey = (publicKey) => {
   return decodeAbiParameters([{ type: "string" }], publicKey)[0];
 };
+function defineChain(chain) {
+  return {
+    formatters: void 0,
+    fees: void 0,
+    serializers: void 0,
+    ...chain
+  };
+}
+const holesky = /* @__PURE__ */ defineChain({
+  id: 17e3,
+  name: "Holesky",
+  nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ["https://ethereum-holesky-rpc.publicnode.com"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Etherscan",
+      url: "https://holesky.etherscan.io",
+      apiUrl: "https://api-holesky.etherscan.io/api"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xca11bde05977b3631167028862be2a173976ca11",
+      blockCreated: 77
+    },
+    ensRegistry: {
+      address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
+      blockCreated: 801613
+    },
+    ensUniversalResolver: {
+      address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
+      blockCreated: 973484
+    }
+  },
+  testnet: true
+});
+const mainnet = /* @__PURE__ */ defineChain({
+  id: 1,
+  name: "Ethereum",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ["https://cloudflare-eth.com"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Etherscan",
+      url: "https://etherscan.io",
+      apiUrl: "https://api.etherscan.io/api"
+    }
+  },
+  contracts: {
+    ensRegistry: {
+      address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
+    },
+    ensUniversalResolver: {
+      address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67",
+      blockCreated: 19258213
+    },
+    multicall3: {
+      address: "0xca11bde05977b3631167028862be2a173976ca11",
+      blockCreated: 14353601
+    }
+  }
+});
+const hoodi = defineChain$1({
+  id: 560048,
+  name: "Hoodi",
+  rpcUrls: {
+    default: {
+      http: ["https://rpc.hoodi.ethpandaops.io"]
+    }
+  },
+  nativeCurrency: {
+    name: "Hoodi Ether",
+    symbol: "ETH",
+    decimals: 18
+  },
+  testnet: true
+});
+const chains = {
+  mainnet,
+  holesky,
+  hoodi
+};
+const chainIds = Object.values(chains).map((chain) => chain.id);
+const networks = Object.values(chains).map((chain) => chain.name);
+const graph_endpoints = {
+  [mainnet.id]: "https://api.studio.thegraph.com/query/71118/ssv-network-ethereum/version/latest",
+  [holesky.id]: "https://api.studio.thegraph.com/query/71118/ssv-network-holesky/version/latest",
+  [hoodi.id]: "https://graph-node-hoodi.stage.ops.ssvlabsinternal.com/subgraphs/name/ssv-bapps-hoodi"
+};
+const rest_endpoints = {
+  [mainnet.id]: "https://api.ssv.network/api/v4/mainnet",
+  [holesky.id]: "https://api.ssv.network/api/v4/holesky",
+  [hoodi.id]: "https://api.ssv.network/api/v4/hoodi"
+};
+const contracts = {
+  [mainnet.id]: {
+    setter: "0xDD9BC35aE942eF0cFa76930954a156B3fF30a4E1",
+    getter: "0xafE830B6Ee262ba11cce5F32fDCd760FFE6a66e4",
+    token: "0x9D65fF81a3c488d585bBfb0Bfe3c7707c7917f54"
+  },
+  [holesky.id]: {
+    setter: "0x38A4794cCEd47d3baf7370CcC43B560D3a1beEFA",
+    getter: "0x352A18AEe90cdcd825d1E37d9939dCA86C00e281",
+    token: "0xad45A78180961079BFaeEe349704F411dfF947C6"
+  },
+  [hoodi.id]: {
+    setter: "0x58410Bef803ECd7E63B23664C586A6DB72DAf59c",
+    getter: "0x5AdDb3f1529C5ec70D77400499eE4bbF328368fe",
+    token: "0x9F5d4Ec84fC4785788aB44F9de973cF34F7A038e"
+  }
+};
 const global = globalThis || void 0 || self;
 var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
 var freeSelf = typeof self == "object" && self && self.Object === Object && self;
@@ -5107,32 +5388,131 @@ var z = /* @__PURE__ */ Object.freeze({
   ZodError
 });
 const configArgsSchema = z.object({
-  walletClient: z.custom((val) => typeof val === "object" && val !== null, {}),
-  publicClient: z.custom((val) => typeof val === "object" && val !== null, {})
+  publicClient: z.custom().superRefine((val, ctx) => {
+    const client = val;
+    if (!client) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Public client must be provided"
+      });
+      return false;
+    }
+    if (client.chain === void 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Public client must have a chain property"
+      });
+      return false;
+    }
+    if (!chainIds.includes(client.chain?.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Public client chain must be one of [${networks.join(", ")}]`
+      });
+      return false;
+    }
+    return true;
+  }),
+  walletClient: z.custom().superRefine((val, ctx) => {
+    const client = val;
+    if (!client) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Wallet client must be provided"
+      });
+      return false;
+    }
+    if (client.chain === void 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Wallet client must have a chain property"
+      });
+      return false;
+    }
+    if (!chainIds.includes(client.chain?.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Wallet client chain must be one of [${networks.join(", ")}]`
+      });
+      return false;
+    }
+    return true;
+  }),
+  _: z.object({
+    graphUrl: z.string().url().optional(),
+    restUrl: z.string().url().optional(),
+    contractAddresses: z.object({
+      setter: z.string().optional(),
+      getter: z.string().optional(),
+      token: z.string().optional()
+    }).optional()
+  }).optional()
 });
+const globals = {
+  MAX_WEI_AMOUNT: 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+  CLUSTER_SIZES: {
+    QUAD_CLUSTER: 4,
+    SEPT_CLUSTER: 7,
+    DECA_CLUSTER: 10,
+    TRISKAIDEKA_CLUSTER: 13
+  },
+  FIXED_VALIDATORS_COUNT_PER_CLUSTER_SIZE: {
+    QUAD_CLUSTER: 80,
+    SEPT_CLUSTER: 40,
+    DECA_CLUSTER: 30,
+    TRISKAIDEKA_CLUSTER: 20
+  },
+  BLOCKS_PER_DAY: 7160n,
+  OPERATORS_PER_PAGE: 50,
+  BLOCKS_PER_YEAR: 2613400n,
+  DEFAULT_CLUSTER_PERIOD: 730,
+  NUMBERS_OF_WEEKS_IN_YEAR: 52.1429,
+  MAX_VALIDATORS_COUNT_MULTI_FLOW: 50,
+  CLUSTER_VALIDITY_PERIOD_MINIMUM: 30,
+  OPERATOR_VALIDATORS_LIMIT_PRESERVE: 5,
+  MINIMUM_OPERATOR_FEE_PER_BLOCK: 1000000000n,
+  MIN_VALIDATORS_COUNT_PER_BULK_REGISTRATION: 1,
+  DEFAULT_ADDRESS_WHITELIST: "0x0000000000000000000000000000000000000000"
+};
+const registerValidatorsByClusterSizeLimits = {
+  [globals.CLUSTER_SIZES.QUAD_CLUSTER]: globals.FIXED_VALIDATORS_COUNT_PER_CLUSTER_SIZE.QUAD_CLUSTER,
+  [globals.CLUSTER_SIZES.SEPT_CLUSTER]: globals.FIXED_VALIDATORS_COUNT_PER_CLUSTER_SIZE.SEPT_CLUSTER,
+  [globals.CLUSTER_SIZES.DECA_CLUSTER]: globals.FIXED_VALIDATORS_COUNT_PER_CLUSTER_SIZE.DECA_CLUSTER,
+  [globals.CLUSTER_SIZES.TRISKAIDEKA_CLUSTER]: globals.FIXED_VALIDATORS_COUNT_PER_CLUSTER_SIZE.TRISKAIDEKA_CLUSTER
+};
 export {
-  bigintRound as A,
-  bigintFloor as B,
-  bigintAbs as C,
-  isBigIntChanged as D,
-  bigintifyNumbers as E,
-  isClusterId as F,
-  add0x as G,
-  KeysharesValidationErrorsMessages as H,
-  numberFormatter as I,
-  percentageFormatter as J,
+  formatSSV as $,
+  ensureNoKeysharesErrors as A,
+  ensureValidatorsUniqueness as B,
+  validateConsistentOperatorPublicKeys as C,
+  validateConsistentOperatorIds as D,
+  sortNumbers as E,
+  KeysharesValidationErrors as F,
+  hoodi as G,
+  chains as H,
+  networks as I,
+  bigintMin as J,
   KeysharesValidationError as K,
-  bigintFormatter as L,
+  bigintRound as L,
   MapCache as M,
-  ethFormatter as N,
-  formatSSV as O,
-  formatBigintInput as P,
-  ms as Q,
-  getOperatorIds as R,
+  bigintFloor as N,
+  bigintAbs as O,
+  isBigIntChanged as P,
+  bigintifyNumbers as Q,
+  isClusterId as R,
   Symbol$1 as S,
+  add0x as T,
   Uint8Array as U,
+  KeysharesValidationErrorsMessages as V,
+  numberFormatter as W,
+  percentageFormatter as X,
+  bigintFormatter as Y,
+  ethFormatter as Z,
   _percentageFormatter as _,
   getTag as a,
+  formatBigintInput as a0,
+  ms as a1,
+  getOperatorIds as a2,
   Stack as b,
   isTypedArray as c,
   decodeOperatorPublicKey as d,
@@ -5143,19 +5523,19 @@ export {
   isBuffer as i,
   isUndefined as j,
   configArgsSchema as k,
-  getClusterSnapshot as l,
-  isKeySharesItem as m,
-  createClusterId as n,
-  createEmptyCluster as o,
-  bigintMax as p,
-  ensureNoKeysharesErrors as q,
-  roundOperatorFee as r,
+  chainIds as l,
+  contracts as m,
+  graph_endpoints as n,
+  getClusterSnapshot as o,
+  process$1 as p,
+  isKeySharesItem as q,
+  rest_endpoints as r,
   stringifyBigints as s,
   tryCatch as t,
-  ensureValidatorsUniqueness as u,
-  validateConsistentOperatorPublicKeys as v,
-  validateConsistentOperatorIds as w,
-  sortNumbers as x,
-  KeysharesValidationErrors as y,
-  bigintMin as z
+  registerValidatorsByClusterSizeLimits as u,
+  createClusterId as v,
+  createEmptyCluster as w,
+  roundOperatorFee as x,
+  globals as y,
+  bigintMax as z
 };