@xyo-network/chain-reward-redemption 1.15.16 → 1.15.18

package/dist/node/index.mjs

@@ -48,10 +48,10 @@ var archivistMiddleware = /* @__PURE__ */ __name((options) => {
   });
   router.post("/insert", async (req, res) => {
     setRawResponseFormat(res);
-    const body3 = Array.isArray(req.body) ? req.body : [
+    const body2 = Array.isArray(req.body) ? req.body : [
       req.body
     ];
-    const payloads = (await PayloadBuilder.hashPairs(body3)).map((p) => p[0]);
+    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);
@@ -111,16 +111,6 @@ var addDataLakeRoutes = /* @__PURE__ */ __name((app) => {
   }));
 }, "addDataLakeRoutes");
 
-// src/server/routes/rewardRedemption/routeDefinitions/routes/claimAddress.ts
-import { asAddress } from "@xylabs/hex";
-import { isUndefined } from "@xylabs/typeof";
-import { createTransferPayload } from "@xyo-network/chain-protocol";
-import { PayloadZodLoose } from "@xyo-network/payload-model";
-import { asStepIdentity } from "@xyo-network/xl1-protocol";
-import { buildTransaction, completedStepRewardAddress, derivedReceiveAddress } from "@xyo-network/xl1-protocol-sdk";
-import { SignedHydratedTransactionZod } from "@xyo-network/xl1-rpc";
-import { z as z2 } from "zod";
-
 // src/server/routes/rewardRedemption/middleware/requestHandlerValidator.ts
 import { isDefined as isDefined2, isPromise } from "@xylabs/typeof";
 import { ReasonPhrases, StatusCodes } from "http-status-codes";
@@ -194,28 +184,12 @@ function requestHandlerValidator(schemas) {
 }
 __name(requestHandlerValidator, "requestHandlerValidator");
 
-// src/server/routes/rewardRedemption/routeDefinitions/pathParams/AddressPathParam.ts
-import { EthAddressFromStringZod } from "@xylabs/hex";
-
-// src/server/routes/rewardRedemption/routeDefinitions/util/getAccountFromConfig.ts
-import { assertEx } from "@xylabs/assert";
-import { isDefined as isDefined3 } from "@xylabs/typeof";
-import { HDWallet } from "@xyo-network/wallet";
-var account;
-var getAccountFromConfig = /* @__PURE__ */ __name(async (config) => {
-  if (isDefined3(account)) {
-    return account;
-  }
-  account = await HDWallet.fromPhrase(assertEx(config.rewardRedemptionApi.mnemonic, () => "Mnemonic is required for reward redemption"));
-  return account;
-}, "getAccountFromConfig");
-
 // src/server/routes/rewardRedemption/routeDefinitions/util/getViewerFromConfig.ts
-import { isDefined as isDefined4 } from "@xylabs/typeof";
+import { isDefined as isDefined3 } from "@xylabs/typeof";
 import { HttpRpcTransport, JsonRpcXyoViewer, XyoViewerRpcSchemas } from "@xyo-network/xl1-rpc";
 var viewer;
 var getViewerFromConfig = /* @__PURE__ */ __name((config) => {
-  if (isDefined4(viewer)) return viewer;
+  if (isDefined3(viewer)) return viewer;
   const transport = new HttpRpcTransport(config.rewardRedemptionApi.chainRpcApiUrl, XyoViewerRpcSchemas);
   viewer = new JsonRpcXyoViewer(transport);
   return viewer;
@@ -231,200 +205,293 @@ var RewardableSteps = [
   8
 ];
 
-// src/server/routes/rewardRedemption/routeDefinitions/routes/claimAddress.ts
+// src/server/routes/rewardRedemption/routeDefinitions/routes/claimRange.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { isDefined as isDefined5 } from "@xylabs/typeof";
+import { blockRangeSteps as blockRangeSteps2 } from "@xyo-network/chain-protocol";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { PayloadZodLoose } from "@xyo-network/payload-model";
+import { asSentinelInstance } from "@xyo-network/sentinel-model";
+import { asXL1BlockNumber as asXL1BlockNumber2 } from "@xyo-network/xl1-protocol";
+import { z as z2 } from "zod";
+
+// src/modules/ChainRewardsClaimSentinel.ts
+import { assertEx } from "@xylabs/assert";
+import { toAddress } from "@xylabs/hex";
+import { isDefined as isDefined4, isUndefined } from "@xylabs/typeof";
+import { blockRangeSteps, createTransferPayload } from "@xyo-network/chain-protocol";
+import { AbstractSentinel } from "@xyo-network/sentinel-abstract";
+import { asXL1BlockNumber, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-protocol";
+import { completedStepRewardAddress, derivedReceiveAddress, flattenHydratedTransaction, flattenHydratedTransactions } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex } from "async-mutex";
+
+// src/modules/StepIdentityPayload.ts
+import { AsObjectFactory } from "@xylabs/object";
+import { isPayloadOfZodType } from "@xyo-network/payload-model";
+import { StepIdentityZod } from "@xyo-network/xl1-rpc";
+var StepIdentitySchema = "network.xyo.chain.step.identity";
+var isStepIdentityPayload = isPayloadOfZodType(StepIdentityZod, StepIdentitySchema);
+var asStepIdentityPayload = AsObjectFactory.create(isStepIdentityPayload);
+
+// src/modules/ChainRewardsClaimSentinel.ts
+var ChainRewardsClaimSentinelConfigSchema = "network.xyo.sentinel.chain.rewards.claim.config";
 var scope = "reward-escrow";
-var params = z2.object({
-  address: EthAddressFromStringZod
-});
-var body = PayloadZodLoose;
-var response = SignedHydratedTransactionZod;
-var validateRequest = requestHandlerValidator({
-  params,
-  body,
-  response
-});
-var getStakesForStaker = /* @__PURE__ */ __name(async (viewer2, stakerAddress) => {
-  const stakes = await viewer2.stakesByStaker(stakerAddress);
-  return stakes;
-}, "getStakesForStaker");
-var getRewardsForStake = /* @__PURE__ */ __name(async (viewer2, stakes, fromBlock = 0, toBlock) => {
-  if (isUndefined(toBlock)) {
-    toBlock = await viewer2.currentBlockNumber();
-  }
-  const rewards = [];
-  for (const stake of stakes) {
-    const { id } = stake;
-    const reward = await viewer2.networkStakeStepRewardsForPosition(id, [
-      fromBlock,
-      toBlock
-    ]);
-    rewards.push(reward);
+var RewardableSteps2 = [
+  3,
+  4,
+  5,
+  6,
+  7,
+  8
+];
+var ChainRewardsClaimSentinel = class extends AbstractSentinel {
+  static {
+    __name(this, "ChainRewardsClaimSentinel");
   }
-  return rewards;
-}, "getRewardsForStake");
-var sumNetworkStakeStepRewards = /* @__PURE__ */ __name((records) => {
-  const totals = {};
-  for (const record of records) {
-    for (const [key, [first]] of Object.entries(record)) {
-      if (isUndefined(totals[key])) {
-        totals[key] = 0n;
-      }
-      totals[key] += first;
-    }
+  static configSchemas = [
+    ChainRewardsClaimSentinelConfigSchema
+  ];
+  static defaultConfigSchema = ChainRewardsClaimSentinelConfigSchema;
+  _reportMutex = new Mutex();
+  get gateway() {
+    return this.params.gateway;
   }
-  return totals;
-}, "sumNetworkStakeStepRewards");
-var postClaim = {
-  method: "post",
-  path: "/rewards/claim/:address",
-  handlers: validateRequest(async (req, res) => {
-    const { config } = req.app;
-    const { address } = req.params;
-    const stakerAddress = asAddress(address);
-    if (!stakerAddress) {
-      res.status(400);
-      return;
+  async reportHandler(payloads) {
+    if (this._reportMutex.isLocked()) {
+      this.logger?.debug(`ChainRewardsClaimSentinel [${this.id}] is already running, skipping divine [${Date.now()}]`);
+      return [];
     }
-    const account2 = await getAccountFromConfig(config);
-    const viewer2 = getViewerFromConfig(config);
-    const stakes = await getStakesForStaker(viewer2, stakerAddress);
-    if (stakes.length > 0) {
-      const currentBlock = await viewer2.currentBlockNumber();
-      const rewards = await getRewardsForStake(viewer2, stakes, 0, currentBlock);
-      if (Object.keys(rewards).length > 0) {
-        const totalRewards = sumNetworkStakeStepRewards(rewards);
-        const totalTransfers = [];
-        for (const [stepIdentityString, accrued] of Object.entries(totalRewards)) {
-          const stepIdentity = asStepIdentity(stepIdentityString);
-          if (isUndefined(stepIdentity)) continue;
-          const stepRewardsAddress = completedStepRewardAddress(stepIdentity);
-          const receiveAddress = derivedReceiveAddress(stakerAddress, scope);
-          const claimed = await viewer2.transferPairBalance([
-            stepRewardsAddress,
-            receiveAddress
-          ]);
-          const unclaimed = accrued - claimed;
-          if (unclaimed <= 0n) continue;
-          const transferPayload = createTransferPayload(stepRewardsAddress, {
-            [receiveAddress]: unclaimed
-          });
-          transferPayload.context = {
-            address: stakerAddress,
-            scope
+    return await this._reportMutex.runExclusive(async () => {
+      const response3 = [];
+      if (isUndefined(payloads) || payloads.length === 0) {
+        await this.claimAllSteps();
+      } else {
+        const stepIdentities = payloads.filter(isStepIdentityPayload).map((p) => {
+          const { step, block: blockNumber } = p;
+          const block = asXL1BlockNumber(blockNumber);
+          return {
+            step,
+            block
           };
-          totalTransfers.push(transferPayload);
+        }).filter((stepIdentity) => RewardableSteps2.includes(stepIdentity.step));
+        for (const stepIdentity of stepIdentities) {
+          const result = await this.claimStepIdentity(stepIdentity);
+          if (isDefined4(result)) response3.push(...flattenHydratedTransaction(result));
         }
-        if (totalTransfers.length > 0) {
-          const chainId = await viewer2.chainId();
-          const tx = await buildTransaction(chainId, totalTransfers, [], account2, currentBlock, currentBlock + 1e3);
-          res.json(tx);
-          return;
+      }
+      return response3;
+    });
+  }
+  calculateAddressDistributions(rewardsByStaker, balance) {
+    const addressClaims = {};
+    const totalRewards = Object.values(rewardsByStaker).reduce((acc, val) => acc + val, 0n);
+    for (const [staker, amount] of Object.entries(rewardsByStaker)) {
+      if (amount <= 0n) continue;
+      const reward = balance * amount / totalRewards;
+      if (reward <= 0n) continue;
+      const receiveAddress = derivedReceiveAddress(toAddress(staker), scope);
+      addressClaims[receiveAddress] = reward;
+    }
+    const totalClaimed = Object.values(addressClaims).reduce((acc, val) => acc + val, 0n);
+    assertEx(totalClaimed <= balance, () => "Total claimed exceeds claimable balance");
+    const unclaimed = balance - totalClaimed;
+    if (unclaimed > 0n) {
+      addressClaims[XYO_STEP_REWARD_ADDRESS] = unclaimed;
+    }
+    return addressClaims;
+  }
+  async claimAllSteps() {
+    const results = [];
+    const connection = await this.gateway.connection();
+    const signer = await this.gateway.signer();
+    const { viewer: viewer2, runner } = connection;
+    if (isDefined4(viewer2) && isDefined4(runner) && isDefined4(signer)) {
+      for (const step of RewardableSteps2) {
+        const from = 0;
+        const to = await viewer2.currentBlockNumber();
+        const range = [
+          asXL1BlockNumber(from),
+          asXL1BlockNumber(to)
+        ];
+        const stepIdentities = blockRangeSteps(range, [
+          step
+        ]);
+        for (const stepIdentity of stepIdentities) {
+          const result = await this.claimStepIdentity(stepIdentity);
+          if (isDefined4(result)) results.push(result);
         }
       }
     }
-    res.status(204);
-  })
+    return flattenHydratedTransactions(results);
+  }
+  async claimStepIdentity(stepIdentity) {
+    const connection = await this.gateway.connection();
+    const signer = await this.gateway.signer();
+    const { viewer: viewer2, runner } = connection;
+    if (isDefined4(viewer2) && isDefined4(runner) && isDefined4(signer)) {
+      const stepRewardsAddress = completedStepRewardAddress(stepIdentity);
+      const balance = await viewer2.accountBalance(stepRewardsAddress);
+      if (balance > 0n) {
+        const rewardsByStaker = await viewer2.networkStakeStepRewardPoolRewards(stepIdentity);
+        const addressDistributions = this.calculateAddressDistributions(rewardsByStaker, balance);
+        const tx = await this.submitRewardDistributionTransaction(stepRewardsAddress, addressDistributions, stepIdentity, this.gateway);
+        return tx;
+      }
+    }
+  }
+  async submitRewardDistributionTransaction(stepRewardsAddress, addressDistributions, step, gateway) {
+    const transferPayload = createTransferPayload(stepRewardsAddress, addressDistributions);
+    transferPayload.context = {
+      step
+    };
+    const connection = await gateway.connection();
+    const viewer2 = assertEx(connection.viewer, () => "Viewer is not defined in gateway connection");
+    const chainId = await viewer2.chainId();
+    const currentBlock = await viewer2.currentBlockNumber();
+    const result = await gateway.addPayloadsToChain?.([
+      transferPayload
+    ], [], {
+      chain: chainId,
+      nbf: currentBlock,
+      exp: currentBlock + 1e3
+    });
+    if (isDefined4(result)) return result[1];
+  }
 };
 
 // src/server/routes/rewardRedemption/routeDefinitions/routes/claimRange.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
-import { toAddress } from "@xylabs/hex";
-import { isDefined as isDefined5 } from "@xylabs/typeof";
-import { blockRangeSteps, createTransferPayload as createTransferPayload2 } from "@xyo-network/chain-protocol";
-import { asXL1BlockNumber, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-protocol";
-import { buildTransaction as buildTransaction2, completedStepRewardAddress as completedStepRewardAddress2, derivedReceiveAddress as derivedReceiveAddress2 } from "@xyo-network/xl1-protocol-sdk";
-import { SignedHydratedTransactionZod as SignedHydratedTransactionZod2 } from "@xyo-network/xl1-rpc";
-import { z as z3 } from "zod";
-var scope2 = "reward-escrow";
-var query = z3.object({
-  fromBlock: z3.coerce.number().int().optional(),
-  toBlock: z3.coerce.number().int().optional()
+var query = z2.object({
+  fromBlock: z2.coerce.number().int().min(0).optional(),
+  toBlock: z2.coerce.number().int().min(0).optional(),
+  step: z2.coerce.number().min(Math.min(...RewardableSteps)).max(Math.max(...RewardableSteps)).int().optional().default(3)
 });
-var response2 = SignedHydratedTransactionZod2.optional();
-var validateRequest2 = requestHandlerValidator({
+var response = z2.array(PayloadZodLoose);
+var validateRequest = requestHandlerValidator({
   query,
-  response: response2
+  response
 });
-var calculateAddressDistributions = /* @__PURE__ */ __name((stakers, balance) => {
-  const addressClaims = {};
-  const totalRewards = Object.values(stakers).reduce((acc, val) => acc + val, 0n);
-  for (const [staker, amount] of Object.entries(stakers)) {
-    const reward = balance * amount / totalRewards;
-    const stakerAddress = toAddress(staker);
-    const receiveAddress = derivedReceiveAddress2(stakerAddress, scope2);
-    addressClaims[receiveAddress] = reward;
-  }
-  const totalClaimed = Object.values(addressClaims).reduce((acc, val) => acc + val, 0n);
-  assertEx2(totalClaimed <= balance, () => "Total claimed exceeds claimable balance");
-  const unclaimed = balance - totalClaimed;
-  if (unclaimed > 0n) {
-    addressClaims[XYO_STEP_REWARD_ADDRESS] = unclaimed;
-  }
-  return addressClaims;
-}, "calculateAddressDistributions");
-var createRewardDistributionTransaction = /* @__PURE__ */ __name(async (stepRewardsAddress, addressDistributions, viewer2, config) => {
-  const transferPayload = createTransferPayload2(stepRewardsAddress, addressDistributions);
-  const chainId = await viewer2.chainId();
-  const account2 = await getAccountFromConfig(config);
-  const currentBlock = await viewer2.currentBlockNumber();
-  const tx = await buildTransaction2(chainId, [
-    transferPayload
-  ], [], account2, currentBlock, currentBlock + 1e3);
-  return tx;
-}, "createRewardDistributionTransaction");
+var getChainRewardsClaimSentinel = /* @__PURE__ */ __name(async (node) => {
+  const mod = await node.resolve("XYORewardRedemptionNode:ChainRewardsClaimSentinel");
+  const sentinel = asSentinelInstance(mod);
+  return assertEx2(sentinel, () => "ChainRewardsClaimSentinel not found on node");
+}, "getChainRewardsClaimSentinel");
 var postClaimRange = {
   method: "post",
   path: "/rewards/claimRange",
-  handlers: validateRequest2(async (req, res) => {
-    const { config } = req.app;
-    const { fromBlock, toBlock } = req.query;
+  handlers: validateRequest(async (req, res) => {
+    const { config, node } = req.app;
+    const mod = await getChainRewardsClaimSentinel(node);
+    const { fromBlock, toBlock, step } = z2.parse(query, req.query);
     const viewer2 = getViewerFromConfig(config);
-    const from = isDefined5(fromBlock) ? Number(fromBlock) : 0;
-    const to = isDefined5(toBlock) ? Number(toBlock) : await viewer2.currentBlockNumber();
+    const from = isDefined5(fromBlock) ? fromBlock : 0;
+    const currentBlock = await viewer2.currentBlockNumber();
+    const to = isDefined5(toBlock) ? Math.min(toBlock, currentBlock) : currentBlock;
+    if (to <= from) {
+      res.status(400);
+      res.json([]);
+      return;
+    }
     const range = [
-      asXL1BlockNumber(from),
-      asXL1BlockNumber(to)
+      asXL1BlockNumber2(from),
+      asXL1BlockNumber2(to)
     ];
-    const stepIdentities = blockRangeSteps(range, RewardableSteps);
+    const stepIdentities = blockRangeSteps2(range, [
+      step
+    ]);
+    const results = [];
     for (const stepIdentity of stepIdentities) {
-      const stepRewardsAddress = completedStepRewardAddress2(stepIdentity);
-      const balance = await viewer2.accountBalance(stepRewardsAddress);
-      if (balance > 0n) {
-        const stakers = await viewer2.networkStakeStepRewardPoolRewards(stepIdentity);
-        const addressDistributions = calculateAddressDistributions(stakers, balance);
-        const tx = await createRewardDistributionTransaction(stepRewardsAddress, addressDistributions, viewer2, config);
-        res.status(200);
-        res.json(tx);
-      }
+      const stepIdentityPayload = new PayloadBuilder2({
+        schema: StepIdentitySchema
+      }).fields(stepIdentity).build();
+      const result = await mod.report([
+        stepIdentityPayload
+      ]);
+      results.push(...result);
     }
-    res.status(204);
-    res.json();
+    res.status(200);
+    res.json(results);
   })
 };
 
 // src/server/routes/rewardRedemption/routeDefinitions/routes/redeem.ts
-import { PayloadZodLoose as PayloadZodLoose2 } from "@xyo-network/payload-model";
-import { z as z4 } from "zod";
-var params2 = z4.object({
-  address: EthAddressFromStringZod
-});
-var body2 = PayloadZodLoose2;
-var response3 = PayloadZodLoose2;
-var validateRequest3 = requestHandlerValidator({
-  params: params2,
-  body: body2,
-  response: response3
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { hexToBigInt, toAddress as toAddress2, toHex } from "@xylabs/hex";
+import { isDefined as isDefined6 } from "@xylabs/typeof";
+import { createTransferPayload as createTransferPayload2 } from "@xyo-network/chain-protocol";
+import { HDWallet } from "@xyo-network/wallet";
+import { verifyEIP712Message } from "@xyo-network/xl1-protocol-sdk";
+import { HttpRpcXyoConnection, MemoryXyoGateway, MemoryXyoSigner, SignedHydratedTransactionZod } from "@xyo-network/xl1-rpc";
+import { z as z3 } from "zod";
+var body = z3.any();
+var response2 = SignedHydratedTransactionZod;
+var validateRequest2 = requestHandlerValidator({
+  body,
+  response: response2
 });
+var getGateway = /* @__PURE__ */ __name(async (config) => {
+  const { mnemonic, chainRpcApiUrl: endpoint } = config.rewardRedemptionApi;
+  const account = await HDWallet.fromPhrase(assertEx3(mnemonic, () => ""));
+  const signer = new MemoryXyoSigner(account);
+  const connection = new HttpRpcXyoConnection({
+    endpoint,
+    account
+  });
+  const gateway = new MemoryXyoGateway(signer, connection);
+  return gateway;
+}, "getGateway");
+var submitRewardDistributionTransaction = /* @__PURE__ */ __name(async (to, amount, nbf, exp, gateway) => {
+  const signer = assertEx3(await gateway.signer(), () => "Signer is not defined in gateway");
+  const from = await signer.address();
+  const transferPayload = createTransferPayload2(from, {
+    [to]: hexToBigInt(toHex(amount))
+  });
+  const connection = await gateway.connection();
+  const viewer2 = assertEx3(connection.viewer, () => "Viewer is not defined in gateway connection");
+  const chain = await viewer2.chainId();
+  const result = await gateway.addPayloadsToChain?.([
+    transferPayload
+  ], [], {
+    chain,
+    nbf,
+    exp
+  });
+  if (isDefined6(result)) return result[1];
+}, "submitRewardDistributionTransaction");
+var parseConfirmedClaimValues = /* @__PURE__ */ __name((values) => {
+  return {
+    from: toAddress2(values.from),
+    to: values["To XL1 Address"],
+    amount: values["XL1 Amount (Hex)"],
+    nbf: values["XL1 Not before block"],
+    exp: values["XL1 Not after block"]
+  };
+}, "parseConfirmedClaimValues");
 var postRedeem = {
   method: "post",
-  path: "/rewards/redeem/:address",
-  handlers: validateRequest3(async (req, res) => {
-    const { body: body3 } = req;
-    await Promise.resolve();
-    const bridgeObservation = {
-      schema: "network.xyo.test"
-    };
-    res.json(bridgeObservation);
+  path: "/rewards/redeem",
+  handlers: validateRequest2(async (req, res) => {
+    const { config } = req.app;
+    const { body: body2 } = req;
+    const [payload, signature] = body2;
+    const valid = await verifyEIP712Message(payload, signature);
+    if (valid) {
+      const values = payload.values;
+      const { from, to, amount, nbf, exp } = parseConfirmedClaimValues(values);
+      assertEx3(toAddress2(signature.address) === toAddress2(from), () => "Signature does not match from address");
+      const gateway = await getGateway(config);
+      const receiver = toAddress2(to);
+      const tx = await submitRewardDistributionTransaction(receiver, amount, nbf, exp, gateway);
+      if (isDefined6(tx)) {
+        res.status(200);
+        res.json(tx);
+      } else {
+        res.status(500);
+        res.json();
+      }
+    } else {
+      res.status(404);
+      res.json();
+    }
   })
 };
 
@@ -432,7 +499,7 @@ var postRedeem = {
 var getRouteDefinitions = /* @__PURE__ */ __name(() => {
   return [
     postClaimRange,
-    postClaim,
+    // postClaim,
     postRedeem
   ];
 }, "getRouteDefinitions");
@@ -474,22 +541,23 @@ var getApp = /* @__PURE__ */ __name((node, config) => {
 }, "getApp");
 
 // src/server/server.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
-import { isDefined as isDefined7, isString } from "@xylabs/typeof";
+import { assertEx as assertEx4 } from "@xylabs/assert";
+import { isDefined as isDefined8, isString } from "@xylabs/typeof";
 import { boot } from "@xyo-network/bios";
-import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
+import { HDWallet as HDWallet3 } from "@xyo-network/wallet";
 
 // src/manifest/getLocator.ts
-import { isDefined as isDefined6 } from "@xylabs/typeof";
+import { isDefined as isDefined7 } from "@xylabs/typeof";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
 import { MongoDBArchivistV2 } from "@xyo-network/archivist-mongodb";
 import { ViewArchivist } from "@xyo-network/archivist-view";
-import { ArchivistSyncDiviner } from "@xyo-network/chain-modules";
 import { initTelemetry } from "@xyo-network/chain-telemetry";
 import { AbstractModule, LoggerModuleStatusReporter } from "@xyo-network/module-abstract";
 import { ModuleFactoryLocator } from "@xyo-network/module-factory-locator";
 import { MemorySentinel } from "@xyo-network/sentinel-memory";
+import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
 import { hasMongoConfig } from "@xyo-network/xl1-protocol-sdk";
+import { HttpRpcXyoConnection as HttpRpcXyoConnection2, MemoryXyoGateway as MemoryXyoGateway2, MemoryXyoSigner as MemoryXyoSigner2 } from "@xyo-network/xl1-rpc";
 var getLocator = /* @__PURE__ */ __name(async (context) => {
   const { config, logger } = context;
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
@@ -504,7 +572,7 @@ var getLocator = /* @__PURE__ */ __name(async (context) => {
       port: 9465
     }
   });
-  if (isDefined6(logger)) AbstractModule.defaultLogger = logger;
+  if (isDefined7(logger)) AbstractModule.defaultLogger = logger;
   const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
   const locator = new ModuleFactoryLocator();
   const mongoConfig = config.storage?.mongo;
@@ -517,13 +585,13 @@ var getLocator = /* @__PURE__ */ __name(async (context) => {
       dbPassword,
       dbUserName
     };
-    const params3 = {
+    const params = {
       meterProvider,
       payloadSdkConfig,
       statusReporter,
       traceProvider
     };
-    locator.register(MongoDBArchivistV2.factory(params3), void 0, true);
+    locator.register(MongoDBArchivistV2.factory(params), void 0, true);
   }
   locator.register(MemoryArchivist.factory({
     traceProvider,
@@ -540,13 +608,27 @@ var getLocator = /* @__PURE__ */ __name(async (context) => {
     meterProvider,
     statusReporter
   }));
-  locator.register(ArchivistSyncDiviner.factory({
+  await registerChainRewardsClaimSentinel(locator, config, traceProvider, meterProvider, statusReporter);
+  return locator;
+}, "getLocator");
+var registerChainRewardsClaimSentinel = /* @__PURE__ */ __name(async (locator, config, traceProvider, meterProvider, statusReporter) => {
+  const { mnemonic, chainRpcApiUrl: endpoint } = config.rewardRedemptionApi;
+  const walletPromise = isDefined7(mnemonic) ? HDWallet2.fromPhrase(mnemonic) : HDWallet2.random();
+  const account = await walletPromise;
+  const signer = new MemoryXyoSigner2(account);
+  const connection = new HttpRpcXyoConnection2({
+    endpoint,
+    account
+  });
+  const gateway = new MemoryXyoGateway2(signer, connection);
+  const chainRewardsClaimSentinelParams = {
+    gateway,
     traceProvider,
     meterProvider,
     statusReporter
-  }));
-  return locator;
-}, "getLocator");
+  };
+  locator.register(ChainRewardsClaimSentinel.factory(chainRewardsClaimSentinelParams));
+}, "registerChainRewardsClaimSentinel");
 
 // src/manifest/getNode.ts
 import { ManifestWrapper } from "@xyo-network/manifest-wrapper";
@@ -576,6 +658,13 @@ var node_default = {
               },
               schema: "network.xyo.archivist.config"
             }
+          },
+          {
+            config: {
+              accountPath: "1/1'/2'",
+              name: "ChainRewardsClaimSentinel",
+              schema: "network.xyo.sentinel.chain.rewards.claim.config"
+            }
           }
         ],
         public: [
@@ -638,20 +727,20 @@ var getSeedPhrase = /* @__PURE__ */ __name(async (bios, config, logger) => {
     if (isString(mnemonic)) {
       seedPhrase = mnemonic;
     } else {
-      seedPhrase = HDWallet2.generateMnemonic();
+      seedPhrase = HDWallet3.generateMnemonic();
       logger?.log("[Bridge] No mnemonic provided, using random mnemonic. This is not recommended for production use.");
       logger?.log(`[Bridge] Mnemonic: ${seedPhrase}`);
     }
     await bios.seedPhraseStore.set("os", seedPhrase);
   }
-  return assertEx3(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
+  return assertEx4(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
 }, "getSeedPhrase");
 var getServer = /* @__PURE__ */ __name(async (context) => {
   const { logger, config } = context;
   const { port, mnemonic } = config.rewardRedemptionApi;
   const bios = await boot();
-  const seedPhrase = isDefined7(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
-  const wallet = await HDWallet2.fromPhrase(seedPhrase);
+  const seedPhrase = isDefined8(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
+  const wallet = await HDWallet3.fromPhrase(seedPhrase);
   const nodeContext = {
     wallet,
     logger,