@xyo-network/chain-reward-redemption 1.23.0 → 2.0.0

package/dist/node/index.mjs

@@ -1,5 +1,15 @@
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/command.ts
 import { RewardRedemptionConfigZod } from "@xyo-network/chain-orchestration";
@@ -11,7 +21,11 @@ import { initActorWallet } from "@xyo-network/chain-orchestration";
 // src/RewardRedemptionActor.ts
 import { creatable } from "@xylabs/sdk-js";
 import { ActorV3 } from "@xyo-network/chain-orchestration";
-import { asHostActorConfigContext, XyoGatewayRunnerMoniker, XyoViewerMoniker as XyoViewerMoniker2 } from "@xyo-network/xl1-sdk";
+import {
+  asHostActorConfigContext,
+  XyoGatewayRunnerMoniker,
+  XyoViewerMoniker as XyoViewerMoniker2
+} from "@xyo-network/xl1-sdk";
 
 // src/server/app.ts
 import { standardErrors } from "@xylabs/express";
@@ -22,278 +36,287 @@ import express2 from "express";
 import { registerInstrumentations } from "@opentelemetry/instrumentation";
 import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
 import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
-var addInstrumentation = /* @__PURE__ */ __name(() => {
-  const instrumentations = [
-    new HttpInstrumentation(),
-    new ExpressInstrumentation()
-  ];
-  registerInstrumentations({
-    instrumentations
-  });
-}, "addInstrumentation");
+var addInstrumentation = () => {
+  const instrumentations = [new HttpInstrumentation(), new ExpressInstrumentation()];
+  registerInstrumentations({ instrumentations });
+};
 
 // src/server/routes/livez/get.ts
 import { setRawResponseFormat } from "@xylabs/express";
 import { ReasonPhrases } from "http-status-codes";
 var message = ReasonPhrases.OK;
-var handler = /* @__PURE__ */ __name((_req, res) => {
+var handler = (_req, res) => {
   setRawResponseFormat(res);
-  res.status(200).send({
-    message
-  });
-}, "handler");
+  res.status(200).send({ message });
+};
 var getLivez = handler;
 
 // src/server/routes/readyz/get.ts
 import { setRawResponseFormat as setRawResponseFormat2 } from "@xylabs/express";
 import { ReasonPhrases as ReasonPhrases2 } from "http-status-codes";
 var message2 = ReasonPhrases2.OK;
-var handler2 = /* @__PURE__ */ __name((_req, res) => {
+var handler2 = (_req, res) => {
   setRawResponseFormat2(res);
-  res.status(200).send({
-    message: message2
-  });
-}, "handler");
+  res.status(200).send({ message: message2 });
+};
 var getReadyz = handler2;
 
 // src/server/routes/startupz/get.ts
 import { setRawResponseFormat as setRawResponseFormat3 } from "@xylabs/express";
 import { ReasonPhrases as ReasonPhrases3 } from "http-status-codes";
 var message3 = ReasonPhrases3.OK;
-var handler3 = /* @__PURE__ */ __name((_req, res) => {
+var handler3 = (_req, res) => {
   setRawResponseFormat3(res);
-  res.status(200).send({
-    message: message3
-  });
-}, "handler");
+  res.status(200).send({ message: message3 });
+};
 var getStartupz = handler3;
 
 // src/server/routes/addProbeRoutes.ts
-var addProbeRoutes = /* @__PURE__ */ __name((app) => {
+var addProbeRoutes = (app) => {
   app.get("/livez", getLivez);
   app.get("/readyz", getReadyz);
   app.get("/startupz", getStartupz);
-}, "addProbeRoutes");
+};
 
 // src/server/routes/dataLake/archivistMiddleware.ts
 import { setRawResponseFormat as setRawResponseFormat4 } from "@xylabs/express";
-import { asHash, isDefined } from "@xylabs/sdk-js";
-import { asArchivistInstance, isAnyPayload, isSequence, PayloadBuilder } from "@xyo-network/sdk-js";
+import {
+  asHash,
+  isDefined,
+  spanAsync
+} from "@xylabs/sdk-js";
+import {
+  asArchivistInstance,
+  isAnyPayload,
+  isSequence,
+  PayloadBuilder
+} from "@xyo-network/sdk-js";
 import express from "express";
-var resolveArchivist = /* @__PURE__ */ __name(async (node, archivistModuleIdentifier) => {
+var resolveArchivist = async (node, archivistModuleIdentifier) => {
   const mod = await node.resolve(archivistModuleIdentifier);
-  return asArchivistInstance(mod, {
-    required: true
-  });
-}, "resolveArchivist");
+  return asArchivistInstance(mod, { required: true });
+};
 var archivistInstance;
-var getArchivist = /* @__PURE__ */ __name(async (node, archivistModuleIdentifier) => {
+var getArchivist = async (node, archivistModuleIdentifier) => {
   if (isDefined(archivistInstance)) return archivistInstance;
   archivistInstance = await resolveArchivist(node, archivistModuleIdentifier);
   return archivistInstance;
-}, "getArchivist");
-var archivistMiddleware = /* @__PURE__ */ __name((options) => {
+};
+var archivistMiddleware = (options) => {
   const { node, archivistModuleIdentifier } = options;
-  const router = express.Router({
-    mergeParams: true
-  });
+  const router = express.Router({ mergeParams: true });
   router.post("/insert", async (req, res) => {
-    setRawResponseFormat4(res);
-    const body2 = Array.isArray(req.body) ? req.body : [
-      req.body
-    ];
-    const payloads = (await PayloadBuilder.hashPairs(body2)).map((p) => p[0]);
-    const archivist = await getArchivist(node, archivistModuleIdentifier);
-    const result = await archivist.insert(payloads);
-    res.status(200).json(result);
+    await spanAsync("reward-redemption:data-lake:insert", async () => {
+      setRawResponseFormat4(res);
+      const body2 = Array.isArray(req.body) ? req.body : [req.body];
+      const payloads = (await PayloadBuilder.hashPairs(body2)).map((p) => p[0]);
+      const archivist = await getArchivist(node, archivistModuleIdentifier);
+      const result = await archivist.insert(payloads);
+      res.status(200).json(result);
+    }, { timeBudgetLimit: 2e3 });
   });
   router.get("/next", async (req, res) => {
-    setRawResponseFormat4(res);
-    const cursor = isSequence(req.query.cursor) ? req.query.cursor : void 0;
-    const limit = isDefined(req.query.limit) ? Number(req.query.limit) : void 0;
-    const open = isDefined(req.query.open) ? Boolean(req.query.open) : void 0;
-    const order = req.query.order === "asc" ? "asc" : "desc";
-    const options2 = {
-      limit,
-      open,
-      order,
-      cursor
-    };
-    const archivist = await getArchivist(node, archivistModuleIdentifier);
-    const result = await archivist.next(options2);
-    res.status(200).json(result);
+    await spanAsync("reward-redemption:data-lake:next-get", async () => {
+      setRawResponseFormat4(res);
+      const cursor = isSequence(req.query.cursor) ? req.query.cursor : void 0;
+      const limit = isDefined(req.query.limit) ? Number(req.query.limit) : void 0;
+      const open = isDefined(req.query.open) ? Boolean(req.query.open) : void 0;
+      const order = req.query.order === "asc" ? "asc" : "desc";
+      const options2 = {
+        limit,
+        open,
+        order,
+        cursor
+      };
+      const archivist = await getArchivist(node, archivistModuleIdentifier);
+      const result = await archivist.next(options2);
+      res.status(200).json(result);
+    }, { timeBudgetLimit: 2e3 });
   });
   router.post("/next", async (req, res) => {
-    setRawResponseFormat4(res);
-    const options2 = req.body;
-    const archivist = await getArchivist(node, archivistModuleIdentifier);
-    const result = await (isDefined(options2) ? archivist.next(options2) : archivist.next());
-    res.status(200).json(result);
+    await spanAsync("reward-redemption:data-lake:next-post", async () => {
+      setRawResponseFormat4(res);
+      const options2 = req.body;
+      const archivist = await getArchivist(node, archivistModuleIdentifier);
+      const result = await (isDefined(options2) ? archivist.next(options2) : archivist.next());
+      res.status(200).json(result);
+    }, { timeBudgetLimit: 2e3 });
   });
   router.get("/get/:hash", async (req, res) => {
-    setRawResponseFormat4(res);
-    const { hash: rawHash } = req.params;
-    const hash = asHash(rawHash);
-    if (isDefined(hash)) {
-      const archivist = await getArchivist(node, archivistModuleIdentifier);
-      const [payload] = await archivist.get([
-        hash
-      ]);
-      if (isAnyPayload(payload)) {
-        res.json(payload);
-        return;
-      } else {
-        res.status(404).send();
-        return;
+    await spanAsync("reward-redemption:data-lake:get", async () => {
+      setRawResponseFormat4(res);
+      const { hash: rawHash } = req.params;
+      const hash = asHash(rawHash);
+      if (isDefined(hash)) {
+        const archivist = await getArchivist(node, archivistModuleIdentifier);
+        const [payload] = await archivist.get([hash]);
+        if (isAnyPayload(payload)) {
+          res.json(payload);
+          return;
+        } else {
+          res.status(404).send();
+          return;
+        }
       }
-    }
-    res.status(400).send();
+      res.status(400).send();
+    }, { timeBudgetLimit: 2e3 });
   });
   return router;
-}, "archivistMiddleware");
+};
 
 // src/server/routes/dataLake/addDataLakeRoutes.ts
-var addDataLakeRoutes = /* @__PURE__ */ __name((app) => {
+var addDataLakeRoutes = (app) => {
   const { node } = app;
   const archivistModuleIdentifier = "Data";
-  app.use("/data", archivistMiddleware({
-    node,
-    archivistModuleIdentifier
-  }));
-}, "addDataLakeRoutes");
+  app.use("/data", archivistMiddleware({ node, archivistModuleIdentifier }));
+};
 
 // src/server/routes/rewardRedemption/addRewardRoutes.ts
 import { addRouteDefinitions } from "@xylabs/express";
 
 // src/server/routes/rewardRedemption/routeDefinitions/routes/claimRange.ts
 import { requestHandlerValidator } from "@xylabs/express";
-import { assertEx, isDefined as isDefined2 } from "@xylabs/sdk-js";
-import { asSentinelInstance, PayloadBuilder as PayloadBuilder2, PayloadZodLoose } from "@xyo-network/sdk-js";
-import { asXL1BlockRange, blockRangeSteps, StepIdentitySchema, XyoViewerMoniker } from "@xyo-network/xl1-sdk";
-import { z } from "zod";
+import {
+  assertEx,
+  isDefined as isDefined2,
+  spanAsync as spanAsync2
+} from "@xylabs/sdk-js";
+import {
+  asSentinelInstance,
+  PayloadBuilder as PayloadBuilder2,
+  PayloadZodLoose
+} from "@xyo-network/sdk-js";
+import {
+  asXL1BlockRange,
+  blockRangeSteps,
+  StepIdentitySchema,
+  XyoViewerMoniker
+} from "@xyo-network/xl1-sdk";
+import { z } from "zod/mini";
 
 // src/server/routes/rewardRedemption/routeDefinitions/util/rewardableSteps.ts
-var RewardableSteps = [
-  3,
-  4,
-  5,
-  6,
-  7,
-  8
-];
+var RewardableSteps = [3, 4, 5, 6, 7, 8];
 
 // src/server/routes/rewardRedemption/routeDefinitions/routes/claimRange.ts
-var query = z.object({
-  fromBlock: z.coerce.number().int().nonnegative().optional(),
-  toBlock: z.coerce.number().int().nonnegative().optional(),
-  step: z.coerce.number().int().nonnegative().min(Math.min(...RewardableSteps)).max(Math.max(...RewardableSteps)).optional().default(3)
+var MIN_STEP = Math.min(...RewardableSteps);
+var MAX_STEP = Math.max(...RewardableSteps);
+var queryFields = z.object({
+  fromBlock: z.optional(z.coerce.number().check(z.multipleOf(1), z.nonnegative())),
+  toBlock: z.optional(z.coerce.number().check(z.multipleOf(1), z.nonnegative())),
+  step: z._default(
+    z.coerce.number().check(z.multipleOf(1), z.nonnegative(), z.gte(MIN_STEP), z.lte(MAX_STEP)),
+    3
+  )
 });
 var response = z.array(PayloadZodLoose);
-var validateRequest = requestHandlerValidator({
-  query,
-  response
-});
-var getChainStepRewardsClaimSentinel = /* @__PURE__ */ __name(async (node) => {
+var validateRequest = requestHandlerValidator({ response });
+var getChainStepRewardsClaimSentinel = async (node) => {
   const mod = await node.resolve("XYORewardRedemptionNode:ChainStepRewardsClaimSentinel");
   const sentinel = asSentinelInstance(mod);
   return assertEx(sentinel, () => "ChainStepRewardsClaimSentinel not found on node");
-}, "getChainStepRewardsClaimSentinel");
+};
 var postClaimRange = {
   method: "post",
   path: "/rewards/claimRange",
   handlers: validateRequest(async (req, res) => {
-    const { locator, node } = req.app;
-    const { fromBlock, toBlock, step } = z.parse(query, req.query);
-    const viewer = await locator.getInstance(XyoViewerMoniker);
-    const from = isDefined2(fromBlock) ? fromBlock : 0;
-    const currentBlock = await viewer.currentBlockNumber();
-    const to = isDefined2(toBlock) ? Math.min(toBlock, currentBlock) : currentBlock;
-    if (to <= from) {
-      res.status(400);
-      res.json([]);
-      return;
-    }
-    const range = asXL1BlockRange([
-      from,
-      to
-    ], {
-      name: "claimRange"
-    });
-    const stepIdentities = blockRangeSteps(range, [
-      step
-    ]);
-    const results = [];
-    for (const stepIdentity of stepIdentities) {
-      const mod = await getChainStepRewardsClaimSentinel(node);
-      const stepIdentityPayload = new PayloadBuilder2({
-        schema: StepIdentitySchema
-      }).fields(stepIdentity).build();
-      const result = await mod.report([
-        stepIdentityPayload
-      ]);
-      results.push(...result);
-    }
-    res.status(200);
-    res.json(results);
+    await spanAsync2("reward-redemption:claim-range", async () => {
+      const { locator, node } = req.app;
+      const {
+        fromBlock,
+        toBlock,
+        step
+      } = z.parse(queryFields, req.query);
+      const viewer = await locator.getInstance(XyoViewerMoniker);
+      const from = isDefined2(fromBlock) ? fromBlock : 0;
+      const currentBlock = await viewer.currentBlockNumber();
+      const to = isDefined2(toBlock) ? Math.min(toBlock, currentBlock) : currentBlock;
+      if (to <= from) {
+        res.status(400);
+        res.json([]);
+        return;
+      }
+      const range = asXL1BlockRange([from, to], { name: "claimRange" });
+      const stepIdentities = blockRangeSteps(range, [step]);
+      const results = [];
+      for (const stepIdentity of stepIdentities) {
+        const mod = await getChainStepRewardsClaimSentinel(node);
+        const stepIdentityPayload = new PayloadBuilder2({ schema: StepIdentitySchema }).fields(stepIdentity).build();
+        const result = await mod.report([stepIdentityPayload]);
+        results.push(...result);
+      }
+      res.status(200);
+      res.json(results);
+    }, { timeBudgetLimit: 5e3 });
   })
 };
 
 // src/server/routes/rewardRedemption/routeDefinitions/routes/redeem.ts
 import { requestHandlerValidator as requestHandlerValidator2 } from "@xylabs/express";
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
-import { asSentinelInstance as asSentinelInstance2, PayloadZodLoose as PayloadZodLoose2, PayloadZodStrictOfSchema } from "@xyo-network/sdk-js";
-import { EIP712DataPayloadFieldsZod, EIP712DataPayloadSchema, EIP712SignaturePayloadFieldsZod, EIP712SignaturePayloadSchema } from "@xyo-network/xl1-sdk";
-import { z as z2 } from "zod";
+import { assertEx as assertEx2, spanAsync as spanAsync3 } from "@xylabs/sdk-js";
+import {
+  asSentinelInstance as asSentinelInstance2,
+  PayloadZodLoose as PayloadZodLoose2,
+  PayloadZodStrictOfSchema
+} from "@xyo-network/sdk-js";
+import {
+  EIP712DataPayloadFieldsZod,
+  EIP712DataPayloadSchema,
+  EIP712SignaturePayloadFieldsZod,
+  EIP712SignaturePayloadSchema
+} from "@xyo-network/xl1-sdk";
+import { z as z2 } from "zod/mini";
 var body = z2.tuple([
-  PayloadZodStrictOfSchema(EIP712DataPayloadSchema).extend(EIP712DataPayloadFieldsZod.shape),
-  PayloadZodStrictOfSchema(EIP712SignaturePayloadSchema).extend(EIP712SignaturePayloadFieldsZod.shape)
+  z2.extend(PayloadZodStrictOfSchema(EIP712DataPayloadSchema), EIP712DataPayloadFieldsZod.shape),
+  z2.extend(PayloadZodStrictOfSchema(EIP712SignaturePayloadSchema), EIP712SignaturePayloadFieldsZod.shape)
 ]);
 var response2 = z2.array(PayloadZodLoose2);
 var validateRequest2 = requestHandlerValidator2({
   body,
   response: response2
 });
-var getDerivedAddressWalletTransferSentinel = /* @__PURE__ */ __name(async (node) => {
+var getDerivedAddressWalletTransferSentinel = async (node) => {
   const mod = await node.resolve("XYORewardRedemptionNode:DerivedAddressWalletTransferSentinel");
   const sentinel = asSentinelInstance2(mod);
   return assertEx2(sentinel, () => "DerivedAddressWalletTransferSentinel not found on node");
-}, "getDerivedAddressWalletTransferSentinel");
+};
 var postRedeem = {
   method: "post",
   path: "/rewards/redeem",
   handlers: validateRequest2(async (req, res) => {
-    const { node } = req.app;
-    const { body: body2 } = req;
-    const sentinel = await getDerivedAddressWalletTransferSentinel(node);
-    const result = await sentinel.report(body2);
-    res.status(200);
-    res.json(result);
+    await spanAsync3("reward-redemption:redeem", async () => {
+      const { node } = req.app;
+      const { body: body2 } = req;
+      const sentinel = await getDerivedAddressWalletTransferSentinel(node);
+      const result = await sentinel.report(body2);
+      res.status(200);
+      res.json(result);
+    }, { timeBudgetLimit: 2e3 });
   })
 };
 
 // src/server/routes/rewardRedemption/routeDefinitions/getRouteDefinitions.ts
-var getRouteDefinitions = /* @__PURE__ */ __name(() => {
+var getRouteDefinitions = () => {
   return [
     postClaimRange,
     postRedeem
   ];
-}, "getRouteDefinitions");
+};
 
 // src/server/routes/rewardRedemption/addRewardRoutes.ts
-var addRewardRedemptionRoutes = /* @__PURE__ */ __name((app) => {
+var addRewardRedemptionRoutes = (app) => {
   const routeDefinitions = getRouteDefinitions();
   addRouteDefinitions(app, routeDefinitions);
-}, "addRewardRedemptionRoutes");
+};
 
 // src/server/routes/addRoutes.ts
-var addRoutes = /* @__PURE__ */ __name((app) => {
+var addRoutes = (app) => {
   addProbeRoutes(app);
   addDataLakeRoutes(app);
   addRewardRedemptionRoutes(app);
-}, "addRoutes");
+};
 
 // src/server/app.ts
-var getApp = /* @__PURE__ */ __name((node, config, locator) => {
+var getApp = (node, config, locator) => {
   addInstrumentation();
   const app = express2();
   sharedMiddleware(app);
@@ -303,7 +326,7 @@ var getApp = /* @__PURE__ */ __name((node, config, locator) => {
   addRoutes(app);
   app.use(standardErrors);
   return app;
-}, "getApp");
+};
 
 // src/server/server.ts
 import { boot } from "@xyo-network/bios";
@@ -315,32 +338,43 @@ import { isDefined as isDefined5 } from "@xylabs/sdk-js";
 import { MongoDBArchivistV2 } from "@xyo-network/archivist-mongodb";
 import { ViewArchivist } from "@xyo-network/archivist-view";
 import { initTelemetry } from "@xyo-network/chain-telemetry";
-import { AbstractModule, LoggerModuleStatusReporter, MemoryArchivist, MemorySentinel, ModuleFactoryLocator } from "@xyo-network/sdk-js";
+import {
+  AbstractModule,
+  LoggerModuleStatusReporter,
+  MemoryArchivist,
+  MemorySentinel,
+  ModuleFactoryLocator
+} from "@xyo-network/sdk-js";
 import { hasMongoConfig } from "@xyo-network/xl1-sdk";
 
 // src/services/modules/ChainStepRewardsClaimSentinel/ChainStepRewardsClaimSentinel.ts
-import { assertEx as assertEx3, delay, isDefined as isDefined3, isUndefined, toAddress } from "@xylabs/sdk-js";
+import {
+  assertEx as assertEx3,
+  delay,
+  isDefined as isDefined3,
+  isUndefined,
+  toAddress
+} from "@xylabs/sdk-js";
 import { AbstractSentinel, asSchema } from "@xyo-network/sdk-js";
-import { asXL1BlockNumber, asXL1BlockRange as asXL1BlockRange2, blockRangeSteps as blockRangeSteps2, completedStepRewardAddress, createTransferPayload, derivedReceiveAddress, flattenHydratedTransaction, flattenHydratedTransactions, isStepIdentityPayload, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-sdk";
+import {
+  asXL1BlockNumber,
+  asXL1BlockRange as asXL1BlockRange2,
+  blockRangeSteps as blockRangeSteps2,
+  completedStepRewardAddress,
+  createTransferPayload,
+  derivedReceiveAddress,
+  flattenHydratedTransaction,
+  flattenHydratedTransactions,
+  isStepIdentityPayload,
+  XYO_STEP_REWARD_ADDRESS
+} from "@xyo-network/xl1-sdk";
 import { Mutex } from "async-mutex";
 var ChainStepRewardsClaimSentinelConfigSchema = asSchema("network.xyo.sentinel.chain.step.rewards.claim.config", true);
 var defaultStepClaimIntervalMs = 15e3;
 var scope = "reward-escrow";
-var DefaultRewardableSteps = [
-  3,
-  4,
-  5,
-  6,
-  7,
-  8
-];
+var DefaultRewardableSteps = [3, 4, 5, 6, 7, 8];
 var ChainStepRewardsClaimSentinel = class extends AbstractSentinel {
-  static {
-    __name(this, "ChainStepRewardsClaimSentinel");
-  }
-  static configSchemas = [
-    ChainStepRewardsClaimSentinelConfigSchema
-  ];
+  static configSchemas = [ChainStepRewardsClaimSentinelConfigSchema];
   static defaultConfigSchema = ChainStepRewardsClaimSentinelConfigSchema;
   _claimAttemptsCounter;
   _claimCheckCounter;
@@ -367,18 +401,10 @@ var ChainStepRewardsClaimSentinel = class extends AbstractSentinel {
   }
   async createHandler() {
     await super.createHandler();
-    this._claimAttemptsCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_attempts_total", {
-      description: "Number of claim attempts"
-    });
-    this._claimCheckCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_check_total", {
-      description: "Number of claim checks"
-    });
-    this._claimSuccessCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_success_total", {
-      description: "Number of claim successes"
-    });
-    this._claimErrorCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_errors_total", {
-      description: "Number of claim errors"
-    });
+    this._claimAttemptsCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_attempts_total", { description: "Number of claim attempts" });
+    this._claimCheckCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_check_total", { description: "Number of claim checks" });
+    this._claimSuccessCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_success_total", { description: "Number of claim successes" });
+    this._claimErrorCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_errors_total", { description: "Number of claim errors" });
     const gateway = assertEx3(this.params.gateway, () => "Gateway parameter is required");
     const connection = assertEx3(gateway.connection, () => "Gateway connection is required");
     const viewer = assertEx3(connection.viewer, () => "Viewer is not defined in gateway connection");
@@ -398,13 +424,8 @@ var ChainStepRewardsClaimSentinel = class extends AbstractSentinel {
       } else {
         const stepIdentities = payloads.filter(isStepIdentityPayload).map((p) => {
           const { step, block: blockNumber } = p;
-          const block = asXL1BlockNumber(blockNumber, {
-            name: "reportHandler"
-          });
-          return {
-            step,
-            block
-          };
+          const block = asXL1BlockNumber(blockNumber, { name: "reportHandler" });
+          return { step, block };
         }).filter((stepIdentity) => this.rewardableSteps.includes(stepIdentity.step));
         for (const stepIdentity of stepIdentities) {
           const result = await this.claimStepIdentity(stepIdentity);
@@ -437,15 +458,8 @@ var ChainStepRewardsClaimSentinel = class extends AbstractSentinel {
     for (const step of this.rewardableSteps) {
       const from = 0;
       const to = await this.viewer.currentBlockNumber();
-      const range = asXL1BlockRange2([
-        from,
-        to
-      ], {
-        name: "claimAllSteps"
-      });
-      const stepIdentities = blockRangeSteps2(range, [
-        step
-      ]);
+      const range = asXL1BlockRange2([from, to], { name: "claimAllSteps" });
+      const stepIdentities = blockRangeSteps2(range, [step]);
       for (const stepIdentity of stepIdentities) {
         const result = await this.claimStepIdentity(stepIdentity);
         if (isDefined3(result)) {
@@ -458,25 +472,28 @@ var ChainStepRewardsClaimSentinel = class extends AbstractSentinel {
   }
   async claimStepIdentity(stepIdentity) {
     this.logger?.info(`Checking rewards to claim for step ${stepIdentity.step} at block ${stepIdentity.block}`);
-    const claimCounterAttributes = {
-      step: stepIdentity.step.toString(),
-      block: stepIdentity.block.toString()
-    };
+    const claimCounterAttributes = { step: stepIdentity.step.toString(), block: stepIdentity.block.toString() };
     try {
       this._claimCheckCounter?.add(1, claimCounterAttributes);
       const stepRewardAddress = completedStepRewardAddress(stepIdentity);
       const balance = await this.viewer.account.balance.accountBalance(stepRewardAddress);
-      this.logger?.info(`Found balance of ${balance} to claim for step ${stepIdentity.step} at block ${stepIdentity.block} in step reward address ${stepRewardAddress}`);
+      this.logger?.info(
+        `Found balance of ${balance} to claim for step ${stepIdentity.step} at block ${stepIdentity.block} in step reward address ${stepRewardAddress}`
+      );
       if (balance > 0n) {
         this._claimAttemptsCounter?.add(1, claimCounterAttributes);
         const rewardsByStaker = await this.viewer.networkStakeStepRewardPoolRewards(stepIdentity);
         const rewardRecipients = Object.keys(rewardsByStaker).length;
-        this.logger?.info(`Found ${rewardRecipients} reward recipients for step ${stepIdentity.step} at block ${stepIdentity.block}`);
+        this.logger?.info(
+          `Found ${rewardRecipients} reward recipients for step ${stepIdentity.step} at block ${stepIdentity.block}`
+        );
         if (!this.config.claimEmptySteps) {
           assertEx3(rewardRecipients > 0, () => "No reward recipients for step");
         }
         const addressDistributions = this.calculateAddressDistributions(rewardsByStaker, balance);
-        this.logger?.info(`Calculated address distributions for step ${stepIdentity.step} at block ${stepIdentity.block} with ${Object.keys(addressDistributions).length} addresses`);
+        this.logger?.info(
+          `Calculated address distributions for step ${stepIdentity.step} at block ${stepIdentity.block} with ${Object.keys(addressDistributions).length} addresses`
+        );
         const tx = await this.submitRewardDistributionTransaction(stepRewardAddress, addressDistributions, stepIdentity, this.gateway);
         this.logger?.info(`Claimed rewards for step ${stepIdentity.step} at block ${stepIdentity.block}`);
         this._claimSuccessCounter?.add(1, claimCounterAttributes);
@@ -489,25 +506,36 @@ var ChainStepRewardsClaimSentinel = class extends AbstractSentinel {
   }
   async submitRewardDistributionTransaction(stepRewardAddress, addressDistributions, step, gateway) {
     const transferPayload = createTransferPayload(stepRewardAddress, addressDistributions);
-    transferPayload.context = {
-      step
-    };
+    transferPayload.context = { step };
     const currentBlockNumber = await this.viewer.currentBlockNumber();
-    const result = await gateway.addPayloadsToChain?.([
-      transferPayload
-    ], [], {
-      nbf: currentBlockNumber,
-      exp: asXL1BlockNumber(currentBlockNumber + 10)
-    });
+    const result = await gateway.addPayloadsToChain?.([transferPayload], [], { nbf: currentBlockNumber, exp: asXL1BlockNumber(currentBlockNumber + 10) });
     if (isDefined3(result)) return result[1];
   }
 };
 
 // src/services/modules/DerivedAddressWalletTransferSentinel/DerivedAddressWalletTransferSentinel.ts
-import { AddressZod, assertEx as assertEx4, EthAddressZod, hexToBigInt, HexZod, isDefined as isDefined4, isUndefined as isUndefined2, toAddress as toAddress2, toHex } from "@xylabs/sdk-js";
+import {
+  AddressZod,
+  assertEx as assertEx4,
+  EthAddressZod,
+  hexToBigInt,
+  HexZod,
+  isDefined as isDefined4,
+  isUndefined as isUndefined2,
+  toAddress as toAddress2,
+  toHex
+} from "@xylabs/sdk-js";
 import { AbstractSentinel as AbstractSentinel2, asSchema as asSchema2 } from "@xyo-network/sdk-js";
-import { createTransferPayload as createTransferPayload2, derivedReceiveAddress as derivedReceiveAddress2, flattenHydratedTransaction as flattenHydratedTransaction2, isEIP712DataPayload, isEIP712SignaturePayload, verifyEIP712Message, XL1BlockNumberZod } from "@xyo-network/xl1-sdk";
-import z3 from "zod";
+import {
+  createTransferPayload as createTransferPayload2,
+  derivedReceiveAddress as derivedReceiveAddress2,
+  flattenHydratedTransaction as flattenHydratedTransaction2,
+  isEIP712DataPayload,
+  isEIP712SignaturePayload,
+  verifyEIP712Message,
+  XL1BlockNumberZod
+} from "@xyo-network/xl1-sdk";
+import { z as z3 } from "zod/mini";
 var DerivedAddressWalletTransferSentinelConfigSchema = asSchema2("network.xyo.sentinel.chain.derived.address.wallet.transfer.config", true);
 var scope2 = "reward-escrow";
 var ConfirmedClaimValuesZod = z3.object({
@@ -515,10 +543,11 @@ var ConfirmedClaimValuesZod = z3.object({
   "To XL1 Address": AddressZod,
   "XL1 Amount": z3.string(),
   "XL1 Amount (Hex)": HexZod,
+  // Hex
   "XL1 Not after block": XL1BlockNumberZod,
   "XL1 Not before block": XL1BlockNumberZod
 });
-var parseConfirmedClaimValues = /* @__PURE__ */ __name((values) => {
+var parseConfirmedClaimValues = (values) => {
   return {
     amount: values["XL1 Amount (Hex)"],
     exp: values["XL1 Not after block"],
@@ -526,14 +555,9 @@ var parseConfirmedClaimValues = /* @__PURE__ */ __name((values) => {
     nbf: values["XL1 Not before block"],
     to: toAddress2(values["To XL1 Address"])
   };
-}, "parseConfirmedClaimValues");
+};
 var DerivedAddressWalletTransferSentinel = class extends AbstractSentinel2 {
-  static {
-    __name(this, "DerivedAddressWalletTransferSentinel");
-  }
-  static configSchemas = [
-    DerivedAddressWalletTransferSentinelConfigSchema
-  ];
+  static configSchemas = [DerivedAddressWalletTransferSentinelConfigSchema];
   static defaultConfigSchema = DerivedAddressWalletTransferSentinelConfigSchema;
   _transferAttemptsCounter;
   _transferErrorCounter;
@@ -543,15 +567,18 @@ var DerivedAddressWalletTransferSentinel = class extends AbstractSentinel2 {
   }
   async createHandler() {
     await super.createHandler();
-    this._transferAttemptsCounter = this.meter?.createCounter("derived_address_wallet_transfer_sentinel_attempts_total", {
-      description: "Number of transfer attempts"
-    });
-    this._transferSuccessCounter = this.meter?.createCounter("derived_address_wallet_transfer_sentinel_success_total", {
-      description: "Number of transfer successes"
-    });
-    this._transferErrorCounter = this.meter?.createCounter("derived_address_wallet_transfer_sentinel_errors_total", {
-      description: "Number of transfer errors"
-    });
+    this._transferAttemptsCounter = this.meter?.createCounter(
+      "derived_address_wallet_transfer_sentinel_attempts_total",
+      { description: "Number of transfer attempts" }
+    );
+    this._transferSuccessCounter = this.meter?.createCounter(
+      "derived_address_wallet_transfer_sentinel_success_total",
+      { description: "Number of transfer successes" }
+    );
+    this._transferErrorCounter = this.meter?.createCounter(
+      "derived_address_wallet_transfer_sentinel_errors_total",
+      { description: "Number of transfer errors" }
+    );
   }
   async reportHandler(payloads) {
     const data = payloads?.find((x) => isEIP712DataPayload(x));
@@ -577,8 +604,14 @@ var DerivedAddressWalletTransferSentinel = class extends AbstractSentinel2 {
     this._transferErrorCounter?.add(1);
     return [];
   }
-  submitRewardDistributionTransaction = /* @__PURE__ */ __name(async (claimValues) => {
-    const { amount, from: address, to, nbf, exp } = claimValues;
+  submitRewardDistributionTransaction = async (claimValues) => {
+    const {
+      amount,
+      from: address,
+      to,
+      nbf,
+      exp
+    } = claimValues;
     const signer = assertEx4(this.gateway.signer, () => "Signer is not defined in gateway");
     const signerAddress = await signer.address();
     const connection = this.gateway.connection;
@@ -591,27 +624,20 @@ var DerivedAddressWalletTransferSentinel = class extends AbstractSentinel2 {
     assertEx4(balance === redemptionAmount, () => "Insufficient balance in escrow account");
     const allowance = await viewer.account.balance.accountBalance(signerAddress);
     assertEx4(allowance > 1000n, () => "Insufficient allowance to transfer from escrow account");
-    const transferPayload = createTransferPayload2(escrowAccount, {
-      [to]: hexToBigInt(toHex(amount))
-    });
-    transferPayload.context = {
-      address,
-      scope: scope2
-    };
+    const transferPayload = createTransferPayload2(escrowAccount, { [to]: hexToBigInt(toHex(amount)) });
+    transferPayload.context = { address, scope: scope2 };
     const chain = await viewer.chainId();
-    const result = await this.gateway.addPayloadsToChain?.([
-      transferPayload
-    ], [], {
+    const result = await this.gateway.addPayloadsToChain?.([transferPayload], [], {
       chain,
       nbf,
       exp
     });
     if (isDefined4(result)) return result[1];
-  }, "submitRewardDistributionTransaction");
+  };
 };
 
 // src/services/manifest/getLocator.ts
-var getLocator = /* @__PURE__ */ __name(async (context, gateway) => {
+var getLocator = async (context, gateway) => {
   const { config, logger } = context;
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
   const { path: endpoint = "/metrics", port = 9467 } = config.telemetry?.metrics?.scrape ?? {};
@@ -621,17 +647,20 @@ var getLocator = /* @__PURE__ */ __name(async (context, gateway) => {
       serviceVersion: "1.0.0"
     },
     otlpEndpoint,
-    metricsConfig: {
-      endpoint,
-      port
-    }
+    metricsConfig: { endpoint, port }
   });
   if (isDefined5(logger)) AbstractModule.defaultLogger = logger;
   const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
   const locator = new ModuleFactoryLocator();
   const mongoConfig = config.storage?.mongo;
   if (hasMongoConfig(mongoConfig)) {
-    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const {
+      connectionString: dbConnectionString,
+      database: dbName,
+      domain: dbDomain,
+      password: dbPassword,
+      username: dbUserName
+    } = mongoConfig;
     const payloadSdkConfig = {
       dbConnectionString,
       dbDomain,
@@ -677,7 +706,7 @@ var getLocator = /* @__PURE__ */ __name(async (context, gateway) => {
   };
   locator.register(DerivedAddressWalletTransferSentinel.factory(derivedAddressWalletTransferSentinelParams));
   return locator;
-}, "getLocator");
+};
 
 // src/services/manifest/getNode.ts
 import { ManifestWrapper } from "@xyo-network/sdk-js";
@@ -779,7 +808,7 @@ var PrivateChildManifests = [];
 var PublicChildManifests = [];
 
 // src/services/manifest/getNode.ts
-var getNode = /* @__PURE__ */ __name(async (context, gateway, wallet) => {
+var getNode = async (context, gateway, wallet) => {
   const locator = await getLocator(context, gateway);
   const wrapper = new ManifestWrapper(NodeManifest, wallet, locator, PublicChildManifests, PrivateChildManifests);
   const [node, ...childNodes] = await wrapper.loadNodes();
@@ -788,11 +817,11 @@ var getNode = /* @__PURE__ */ __name(async (context, gateway, wallet) => {
     await Promise.all(childNodes.map((childNode) => node.attach(childNode.address, true)));
   }
   return node;
-}, "getNode");
+};
 
 // src/server/server.ts
 var hostname = "::";
-var getServer = /* @__PURE__ */ __name(async (context, gateway, locator, providedNode) => {
+var getServer = async (context, gateway, locator, providedNode) => {
   const { logger, config } = context;
   const { port } = config;
   const bios = await boot();
@@ -809,26 +838,10 @@ var getServer = /* @__PURE__ */ __name(async (context, gateway, locator, provide
   });
   server.setTimeout(12e4);
   return server;
-}, "getServer");
+};
 
 // src/RewardRedemptionActor.ts
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
 var RewardRedemptionActor = class extends ActorV3 {
-  static {
-    __name(this, "RewardRedemptionActor");
-  }
-  static needs = {
-    required: [
-      XyoGatewayRunnerMoniker,
-      XyoViewerMoniker2
-    ]
-  };
   _gatewayRunner;
   server;
   get gatewayRunner() {
@@ -855,7 +868,13 @@ var RewardRedemptionActor = class extends ActorV3 {
     this.server = void 0;
   }
 };
-RewardRedemptionActor = _ts_decorate([
+__publicField(RewardRedemptionActor, "needs", {
+  required: [
+    XyoGatewayRunnerMoniker,
+    XyoViewerMoniker2
+  ]
+});
+RewardRedemptionActor = __decorateClass([
   creatable()
 ], RewardRedemptionActor);
 
@@ -873,18 +892,14 @@ async function getRewardRedemptionActor(config, locator) {
     locator
   });
 }
-__name(getRewardRedemptionActor, "getRewardRedemptionActor");
 async function runRewardRedemptionApi(config, orchestrator, locator) {
   const rewardRedemption = await getRewardRedemptionActor(config, locator);
-  const actors = [
-    rewardRedemption
-  ].filter(exists);
+  const actors = [rewardRedemption].filter(exists);
   for (const actor of actors) {
     await orchestrator.registerActor(actor);
   }
   await orchestrator.start();
 }
-__name(runRewardRedemptionApi, "runRewardRedemptionApi");
 
 // src/command.ts
 function rewardRedemptionCommand(getConfiguration, getLocatorsFromConfig) {
@@ -892,16 +907,13 @@ function rewardRedemptionCommand(getConfiguration, getLocatorsFromConfig) {
     command: "reward-redemption-api",
     deprecated: 'Use "start rewardRedemption" instead',
     describe: "Run a XL1 Rewards Redemption API Node",
-    handler: /* @__PURE__ */ __name(async () => {
+    handler: async () => {
       const configuration = getConfiguration();
-      const { locators, orchestrator } = await getLocatorsFromConfig([
-        "rewardRedemption"
-      ], configuration);
+      const { locators, orchestrator } = await getLocatorsFromConfig(["rewardRedemption"], configuration);
       await runRewardRedemptionApi(RewardRedemptionConfigZod.parse(locators["rewardRedemption"].context.config), orchestrator, locators["rewardRedemption"]);
-    }, "handler")
+    }
   };
 }
-__name(rewardRedemptionCommand, "rewardRedemptionCommand");
 export {
   ChainStepRewardsClaimSentinel,
   ChainStepRewardsClaimSentinelConfigSchema,
@@ -918,4 +930,4 @@ export {
   rewardRedemptionCommand,
   runRewardRedemptionApi
 };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map