@xyo-network/chain-reward-redemption 1.15.21 → 1.15.23

package/dist/node/index.mjs

@@ -111,121 +111,44 @@ var addDataLakeRoutes = /* @__PURE__ */ __name((app) => {
   }));
 }, "addDataLakeRoutes");
 
-// src/server/routes/rewardRedemption/middleware/requestHandlerValidator.ts
-import { isDefined as isDefined2, isPromise } from "@xylabs/typeof";
-import { ReasonPhrases, StatusCodes } from "http-status-codes";
-import { z } from "zod";
-var EmptyParamsZod = z.object({}).catchall(z.string());
-var EmptyQueryParamsZod = z.object({}).catchall(z.union([
-  z.string(),
-  z.array(z.string())
-]));
-var ValidateRequestDefaults = {
-  params: EmptyParamsZod,
-  query: EmptyQueryParamsZod,
-  body: z.json().optional(),
-  response: z.json().optional()
-};
-function requestHandlerValidator(schemas) {
-  const validators = {
-    ...ValidateRequestDefaults,
-    ...schemas
-  };
-  return (handler) => {
-    return async (req, res, next) => {
-      const originalJson = res.json.bind(res);
-      try {
-        const errors = [];
-        const keys = [
-          "params",
-          "query",
-          "body"
-        ];
-        for (const key of keys) {
-          const validator = validators[key];
-          const result2 = validator.safeParse(req[key]);
-          if (result2.success) {
-            if (isDefined2(result2.data)) Object.assign(req[key], result2.data);
-          } else {
-            errors.push(...result2.error.issues.map((issue) => issue.path.length === 0 ? `${key}: ${issue.message}` : `${key}.${issue.path.join(".")}: ${issue.message}`));
-          }
-        }
-        if (errors.length > 0) {
-          const message = errors.join("; ");
-          const err = new Error(message);
-          err.name = ReasonPhrases.BAD_REQUEST;
-          err.statusCode = StatusCodes.BAD_REQUEST;
-          next(err);
-          return false;
-        }
-        res.json = (data) => {
-          const result2 = validators.response.safeParse(data);
-          if (result2.success) {
-            return originalJson(result2.data);
-          } else {
-            const message = result2.error.issues.map((issue) => issue.path.length === 0 ? `response: ${issue.message}` : `response.${issue.path.join(".")}: ${issue.message}`).join("; ");
-            const err = new Error(message);
-            err.name = ReasonPhrases.INTERNAL_SERVER_ERROR;
-            err.statusCode = StatusCodes.INTERNAL_SERVER_ERROR;
-            res.json = originalJson;
-            throw err;
-          }
-        };
-        const result = handler(req, res, next);
-        if (result && isPromise(result)) {
-          await result;
-        }
-      } catch (err) {
-        res.json = originalJson;
-        next(err);
-      }
-    };
-  };
-}
-__name(requestHandlerValidator, "requestHandlerValidator");
-
-// src/server/routes/rewardRedemption/routeDefinitions/util/getViewerFromConfig.ts
-import { isDefined as isDefined3 } from "@xylabs/typeof";
-import { HttpRpcTransport, JsonRpcXyoViewer, XyoViewerRpcSchemas } from "@xyo-network/xl1-rpc";
-var viewer;
-var getViewerFromConfig = /* @__PURE__ */ __name((config) => {
-  if (isDefined3(viewer)) return viewer;
-  const transport = new HttpRpcTransport(config.rewardRedemptionApi.chainRpcApiUrl, XyoViewerRpcSchemas);
-  viewer = new JsonRpcXyoViewer(transport);
-  return viewer;
-}, "getViewerFromConfig");
-
-// src/server/routes/rewardRedemption/routeDefinitions/util/rewardableSteps.ts
-var RewardableSteps = [
-  3,
-  4,
-  5,
-  6,
-  7,
-  8
-];
-
 // src/server/routes/rewardRedemption/routeDefinitions/routes/claimRange.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
-import { isDefined as isDefined5 } from "@xylabs/typeof";
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { isDefined as isDefined6 } 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";
+import { z as z3 } from "zod";
 
-// src/modules/ChainRewardsClaimSentinel.ts
+// src/modules/ChainStepRewardsClaimSentinel/ChainStepRewardsClaimSentinel.ts
 import { assertEx } from "@xylabs/assert";
 import { toAddress } from "@xylabs/hex";
-import { isDefined as isDefined4, isUndefined } from "@xylabs/typeof";
+import { isDefined as isDefined2, 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
+// src/modules/helper/retry.ts
+import { delay } from "@xylabs/delay";
+async function retry(fn, delayMs = 1e3, retries = 3) {
+  let lastError;
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= retries) throw lastError;
+      if (delayMs > 0) await delay(delayMs);
+    }
+  }
+  throw new Error("Retry logic failed unexpectedly");
+}
+__name(retry, "retry");
+
+// src/modules/ChainStepRewardsClaimSentinel/StepIdentityPayload.ts
 import { AsObjectFactory } from "@xylabs/object";
 import { isPayloadOfZodType } from "@xyo-network/payload-model";
 import { StepIdentityZod } from "@xyo-network/xl1-rpc";
@@ -233,10 +156,12 @@ 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";
+// src/modules/ChainStepRewardsClaimSentinel/ChainStepRewardsClaimSentinel.ts
+var ChainStepRewardsClaimSentinelConfigSchema = "network.xyo.sentinel.chain.step.rewards.claim.config";
+var retryAttempts = 3;
+var retryDelayMs = 6e4;
 var scope = "reward-escrow";
-var RewardableSteps2 = [
+var RewardableSteps = [
   3,
   4,
   5,
@@ -244,14 +169,14 @@ var RewardableSteps2 = [
   7,
   8
 ];
-var ChainRewardsClaimSentinel = class extends AbstractSentinel {
+var ChainStepRewardsClaimSentinel = class extends AbstractSentinel {
   static {
-    __name(this, "ChainRewardsClaimSentinel");
+    __name(this, "ChainStepRewardsClaimSentinel");
   }
   static configSchemas = [
-    ChainRewardsClaimSentinelConfigSchema
+    ChainStepRewardsClaimSentinelConfigSchema
   ];
-  static defaultConfigSchema = ChainRewardsClaimSentinelConfigSchema;
+  static defaultConfigSchema = ChainStepRewardsClaimSentinelConfigSchema;
   _claimAttemptsCounter;
   _claimCheckCounter;
   _claimErrorCounter;
@@ -262,16 +187,16 @@ var ChainRewardsClaimSentinel = class extends AbstractSentinel {
   }
   async createHandler() {
     await super.createHandler();
-    this._claimAttemptsCounter = this.meter?.createCounter("chain_rewards_claim_sentinel_attempts_total", {
+    this._claimAttemptsCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_attempts_total", {
       description: "Number of claim attempts"
     });
-    this._claimCheckCounter = this.meter?.createCounter("chain_rewards_claim_sentinel_check_total", {
+    this._claimCheckCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_check_total", {
       description: "Number of claim checks"
     });
-    this._claimSuccessCounter = this.meter?.createCounter("chain_rewards_claim_sentinel_success_total", {
+    this._claimSuccessCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_success_total", {
       description: "Number of claim successes"
     });
-    this._claimErrorCounter = this.meter?.createCounter("chain_rewards_claim_sentinel_errors_total", {
+    this._claimErrorCounter = this.meter?.createCounter("chain_step_rewards_claim_sentinel_errors_total", {
       description: "Number of claim errors"
     });
   }
@@ -292,10 +217,10 @@ var ChainRewardsClaimSentinel = class extends AbstractSentinel {
             step,
             block
           };
-        }).filter((stepIdentity) => RewardableSteps2.includes(stepIdentity.step));
+        }).filter((stepIdentity) => RewardableSteps.includes(stepIdentity.step));
         for (const stepIdentity of stepIdentities) {
           const result = await this.claimStepIdentity(stepIdentity);
-          if (isDefined4(result)) response3.push(...flattenHydratedTransaction(result));
+          if (isDefined2(result)) response3.push(...flattenHydratedTransaction(result));
         }
       }
       return response3;
@@ -323,8 +248,8 @@ var ChainRewardsClaimSentinel = class extends AbstractSentinel {
     const results = [];
     const connection = await this.gateway.connection();
     const { viewer: viewer2 } = connection;
-    if (isDefined4(viewer2)) {
-      for (const step of RewardableSteps2) {
+    if (isDefined2(viewer2)) {
+      for (const step of RewardableSteps) {
         const from = 0;
         const to = await viewer2.currentBlockNumber();
         const range = [
@@ -336,7 +261,7 @@ var ChainRewardsClaimSentinel = class extends AbstractSentinel {
         ]);
         for (const stepIdentity of stepIdentities) {
           const result = await this.claimStepIdentity(stepIdentity);
-          if (isDefined4(result)) results.push(result);
+          if (isDefined2(result)) results.push(result);
         }
       }
     }
@@ -355,9 +280,9 @@ var ChainRewardsClaimSentinel = class extends AbstractSentinel {
       const stepRewardAddress = completedStepRewardAddress(stepIdentity);
       const balance = await viewer2.accountBalance(stepRewardAddress);
       if (balance > 0n) {
-        this.logger?.info(`Found rewards to claim for step ${stepIdentity.step} at block ${stepIdentity.block}`);
+        this.logger?.info(`Found balance of ${balance} to claim for step ${stepIdentity.step} at block ${stepIdentity.block}`);
         this._claimAttemptsCounter?.add(1, claimCounterAttributes);
-        const rewardsByStaker = await viewer2.networkStakeStepRewardPoolRewards(stepIdentity);
+        const rewardsByStaker = await retry(() => viewer2.networkStakeStepRewardPoolRewards(stepIdentity), retryDelayMs, retryAttempts);
         const addressDistributions = this.calculateAddressDistributions(rewardsByStaker, balance);
         const tx = await this.submitRewardDistributionTransaction(stepRewardAddress, addressDistributions, stepIdentity, this.gateway);
         this.logger?.info(`Claimed rewards for step ${stepIdentity.step} at block ${stepIdentity.block}`);
@@ -385,36 +310,241 @@ var ChainRewardsClaimSentinel = class extends AbstractSentinel {
       nbf: currentBlock,
       exp: currentBlock + 1e3
     });
-    if (isDefined4(result)) return result[1];
+    if (isDefined2(result)) return result[1];
   }
 };
 
+// src/modules/DerivedAddressWalletTransferSentinel/DerivedAddressWalletTransferSentinel.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { AddressZod, EthAddressZod, hexToBigInt, HexZod, toAddress as toAddress2, toHex } from "@xylabs/hex";
+import { isDefined as isDefined3, isUndefined as isUndefined2 } from "@xylabs/typeof";
+import { createTransferPayload as createTransferPayload2 } from "@xyo-network/chain-protocol";
+import { AbstractSentinel as AbstractSentinel2 } from "@xyo-network/sentinel-abstract";
+import { derivedReceiveAddress as derivedReceiveAddress2, flattenHydratedTransaction as flattenHydratedTransaction2, isEIP712DataPayload, isEIP712SignaturePayload, verifyEIP712Message } from "@xyo-network/xl1-protocol-sdk";
+import z from "zod";
+var DerivedAddressWalletTransferSentinelConfigSchema = "network.xyo.sentinel.chain.derived.address.wallet.transfer.config";
+var scope2 = "reward-escrow";
+var ConfirmedClaimValuesZod = z.object({
+  "From": EthAddressZod,
+  "To XL1 Address": AddressZod,
+  "XL1 Amount": z.string(),
+  "XL1 Amount (Hex)": HexZod,
+  "XL1 Not after block": z.number().int().nonnegative(),
+  "XL1 Not before block": z.number().int().nonnegative()
+});
+var parseConfirmedClaimValues = /* @__PURE__ */ __name((values) => {
+  return {
+    amount: values["XL1 Amount (Hex)"],
+    exp: values["XL1 Not after block"],
+    from: toAddress2(values.From),
+    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 defaultConfigSchema = DerivedAddressWalletTransferSentinelConfigSchema;
+  _transferAttemptsCounter;
+  _transferErrorCounter;
+  _transferSuccessCounter;
+  get gateway() {
+    return this.params.gateway;
+  }
+  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"
+    });
+  }
+  async reportHandler(payloads) {
+    const data = payloads?.find(isEIP712DataPayload);
+    const signature = payloads?.find(isEIP712SignaturePayload);
+    if (isUndefined2(data) || isUndefined2(signature)) return [];
+    this._transferAttemptsCounter?.add(1);
+    const valid = await verifyEIP712Message(data, signature);
+    if (!valid) {
+      this._transferErrorCounter?.add(1);
+      throw new Error("Invalid EIP712 signature");
+    }
+    const values = data.values;
+    const parsed = parseConfirmedClaimValues(values);
+    const signatureAddress = toAddress2(signature.address);
+    const parsedAddress = toAddress2(parsed.from);
+    if (signatureAddress === parsedAddress) {
+      const tx = await this.submitRewardDistributionTransaction(parsed);
+      if (isDefined3(tx)) {
+        this._transferSuccessCounter?.add(1);
+        return flattenHydratedTransaction2(tx);
+      }
+    }
+    this._transferErrorCounter?.add(1);
+    return [];
+  }
+  submitRewardDistributionTransaction = /* @__PURE__ */ __name(async (claimValues) => {
+    const { amount, from: address, to, nbf, exp } = claimValues;
+    const signer = assertEx2(await this.gateway.signer(), () => "Signer is not defined in gateway");
+    const signerAddress = await signer.address();
+    const connection = await this.gateway.connection();
+    const viewer2 = assertEx2(connection.viewer, () => "Viewer is not defined in gateway connection");
+    const chainId = await viewer2.chainId();
+    const currentBlock = await viewer2.currentBlockNumber();
+    if (currentBlock < nbf || currentBlock > exp) throw new Error("Transaction is not within a valid block range");
+    const escrowAccount = derivedReceiveAddress2(address, scope2);
+    const balance = await viewer2.accountBalance(escrowAccount);
+    const redemptionAmount = hexToBigInt(toHex(amount));
+    assertEx2(balance === redemptionAmount, () => "Insufficient balance in escrow account");
+    const allowance = await viewer2.accountBalance(signerAddress);
+    assertEx2(allowance > 1000n, () => "Insufficient allowance to transfer from escrow account");
+    const transferPayload = createTransferPayload2(escrowAccount, {
+      [to]: hexToBigInt(toHex(amount))
+    });
+    transferPayload.context = {
+      address,
+      scope: scope2
+    };
+    const chain = await viewer2.chainId();
+    const result = await this.gateway.addPayloadsToChain?.([
+      transferPayload
+    ], [], {
+      chain,
+      nbf,
+      exp
+    });
+    if (isDefined3(result)) return result[1];
+  }, "submitRewardDistributionTransaction");
+};
+
+// src/server/routes/rewardRedemption/middleware/requestHandlerValidator.ts
+import { isDefined as isDefined4, isPromise } from "@xylabs/typeof";
+import { ReasonPhrases, StatusCodes } from "http-status-codes";
+import { z as z2 } from "zod";
+var EmptyParamsZod = z2.object({}).catchall(z2.string());
+var EmptyQueryParamsZod = z2.object({}).catchall(z2.union([
+  z2.string(),
+  z2.array(z2.string())
+]));
+var ValidateRequestDefaults = {
+  params: EmptyParamsZod,
+  query: EmptyQueryParamsZod,
+  body: z2.json().optional(),
+  response: z2.json().optional()
+};
+function requestHandlerValidator(schemas) {
+  const validators = {
+    ...ValidateRequestDefaults,
+    ...schemas
+  };
+  return (handler) => {
+    return async (req, res, next) => {
+      const originalJson = res.json.bind(res);
+      try {
+        const errors = [];
+        const keys = [
+          "params",
+          "query",
+          "body"
+        ];
+        for (const key of keys) {
+          const validator = validators[key];
+          const result2 = validator.safeParse(req[key]);
+          if (result2.success) {
+            if (isDefined4(result2.data)) Object.assign(req[key], result2.data);
+          } else {
+            errors.push(...result2.error.issues.map((issue) => issue.path.length === 0 ? `${key}: ${issue.message}` : `${key}.${issue.path.join(".")}: ${issue.message}`));
+          }
+        }
+        if (errors.length > 0) {
+          const message = errors.join("; ");
+          const err = new Error(message);
+          err.name = ReasonPhrases.BAD_REQUEST;
+          err.statusCode = StatusCodes.BAD_REQUEST;
+          next(err);
+          return false;
+        }
+        res.json = (data) => {
+          const result2 = validators.response.safeParse(data);
+          if (result2.success) {
+            return originalJson(result2.data);
+          } else {
+            const message = result2.error.issues.map((issue) => issue.path.length === 0 ? `response: ${issue.message}` : `response.${issue.path.join(".")}: ${issue.message}`).join("; ");
+            const err = new Error(message);
+            err.name = ReasonPhrases.INTERNAL_SERVER_ERROR;
+            err.statusCode = StatusCodes.INTERNAL_SERVER_ERROR;
+            res.json = originalJson;
+            throw err;
+          }
+        };
+        const result = handler(req, res, next);
+        if (result && isPromise(result)) {
+          await result;
+        }
+      } catch (err) {
+        res.json = originalJson;
+        next(err);
+      }
+    };
+  };
+}
+__name(requestHandlerValidator, "requestHandlerValidator");
+
+// src/server/routes/rewardRedemption/routeDefinitions/util/getViewerFromConfig.ts
+import { isDefined as isDefined5 } from "@xylabs/typeof";
+import { HttpRpcTransport, JsonRpcXyoViewer, XyoViewerRpcSchemas } from "@xyo-network/xl1-rpc";
+var viewer;
+var getViewerFromConfig = /* @__PURE__ */ __name((config) => {
+  if (isDefined5(viewer)) return viewer;
+  const transport = new HttpRpcTransport(config.rewardRedemptionApi.chainRpcApiUrl, XyoViewerRpcSchemas);
+  viewer = new JsonRpcXyoViewer(transport);
+  return viewer;
+}, "getViewerFromConfig");
+
+// src/server/routes/rewardRedemption/routeDefinitions/util/rewardableSteps.ts
+var RewardableSteps2 = [
+  3,
+  4,
+  5,
+  6,
+  7,
+  8
+];
+
 // src/server/routes/rewardRedemption/routeDefinitions/routes/claimRange.ts
-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 query = z3.object({
+  fromBlock: z3.coerce.number().int().nonnegative().optional(),
+  toBlock: z3.coerce.number().int().nonnegative().optional(),
+  step: z3.coerce.number().int().nonnegative().min(Math.min(...RewardableSteps2)).max(Math.max(...RewardableSteps2)).optional().default(3)
 });
-var response = z2.array(PayloadZodLoose);
+var response = z3.array(PayloadZodLoose);
 var validateRequest = requestHandlerValidator({
   query,
   response
 });
-var getChainRewardsClaimSentinel = /* @__PURE__ */ __name(async (node) => {
-  const mod = await node.resolve("XYORewardRedemptionNode:ChainRewardsClaimSentinel");
+var getChainStepRewardsClaimSentinel = /* @__PURE__ */ __name(async (node) => {
+  const mod = await node.resolve("XYORewardRedemptionNode:ChainStepRewardsClaimSentinel");
   const sentinel = asSentinelInstance(mod);
-  return assertEx2(sentinel, () => "ChainRewardsClaimSentinel not found on node");
-}, "getChainRewardsClaimSentinel");
+  return assertEx3(sentinel, () => "ChainStepRewardsClaimSentinel not found on node");
+}, "getChainStepRewardsClaimSentinel");
 var postClaimRange = {
   method: "post",
   path: "/rewards/claimRange",
   handlers: validateRequest(async (req, res) => {
     const { config, node } = req.app;
-    const { fromBlock, toBlock, step } = z2.parse(query, req.query);
+    const { fromBlock, toBlock, step } = z3.parse(query, req.query);
     const viewer2 = getViewerFromConfig(config);
-    const from = isDefined5(fromBlock) ? fromBlock : 0;
+    const from = isDefined6(fromBlock) ? fromBlock : 0;
     const currentBlock = await viewer2.currentBlockNumber();
-    const to = isDefined5(toBlock) ? Math.min(toBlock, currentBlock) : currentBlock;
+    const to = isDefined6(toBlock) ? Math.min(toBlock, currentBlock) : currentBlock;
     if (to <= from) {
       res.status(400);
       res.json([]);
@@ -429,7 +559,7 @@ var postClaimRange = {
     ]);
     const results = [];
     for (const stepIdentity of stepIdentities) {
-      const mod = await getChainRewardsClaimSentinel(node);
+      const mod = await getChainStepRewardsClaimSentinel(node);
       const stepIdentityPayload = new PayloadBuilder2({
         schema: StepIdentitySchema
       }).fields(stepIdentity).build();
@@ -444,84 +574,35 @@ var postClaimRange = {
 };
 
 // src/server/routes/rewardRedemption/routeDefinitions/routes/redeem.ts
-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;
+import { assertEx as assertEx4 } from "@xylabs/assert";
+import { PayloadZodLoose as PayloadZodLoose2, PayloadZodStrictOfSchema } from "@xyo-network/payload-model";
+import { asSentinelInstance as asSentinelInstance2 } from "@xyo-network/sentinel-model";
+import { EIP712DataPayloadFieldsZod, EIP712DataPayloadSchema, EIP712SignaturePayloadFieldsZod, EIP712SignaturePayloadSchema } from "@xyo-network/xl1-protocol-sdk";
+import { z as z4 } from "zod";
+var body = z4.tuple([
+  PayloadZodStrictOfSchema(EIP712DataPayloadSchema).extend(EIP712DataPayloadFieldsZod.shape),
+  PayloadZodStrictOfSchema(EIP712SignaturePayloadSchema).extend(EIP712SignaturePayloadFieldsZod.shape)
+]);
+var response2 = z4.array(PayloadZodLoose2);
 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 getDerivedAddressWalletTransferSentinel = /* @__PURE__ */ __name(async (node) => {
+  const mod = await node.resolve("XYORewardRedemptionNode:DerivedAddressWalletTransferSentinel");
+  const sentinel = asSentinelInstance2(mod);
+  return assertEx4(sentinel, () => "DerivedAddressWalletTransferSentinel not found on node");
+}, "getDerivedAddressWalletTransferSentinel");
 var postRedeem = {
   method: "post",
   path: "/rewards/redeem",
   handlers: validateRequest2(async (req, res) => {
-    const { config } = req.app;
+    const { node } = 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();
-    }
+    const sentinel = await getDerivedAddressWalletTransferSentinel(node);
+    const result = await sentinel.report(body2);
+    res.status(200);
+    res.json(result);
   })
 };
 
@@ -529,7 +610,6 @@ var postRedeem = {
 var getRouteDefinitions = /* @__PURE__ */ __name(() => {
   return [
     postClaimRange,
-    // postClaim,
     postRedeem
   ];
 }, "getRouteDefinitions");
@@ -571,10 +651,10 @@ var getApp = /* @__PURE__ */ __name((node, config) => {
 }, "getApp");
 
 // src/server/server.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
+import { assertEx as assertEx5 } from "@xylabs/assert";
 import { isDefined as isDefined8, isString } from "@xylabs/typeof";
 import { boot } from "@xyo-network/bios";
-import { HDWallet as HDWallet3 } from "@xyo-network/wallet";
+import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
 
 // src/manifest/getLocator.ts
 import { isDefined as isDefined7 } from "@xylabs/typeof";
@@ -585,9 +665,9 @@ 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 { HDWallet } 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";
+import { HttpRpcXyoConnection, MemoryXyoGateway, MemoryXyoSigner } from "@xyo-network/xl1-rpc";
 var getLocator = /* @__PURE__ */ __name(async (context) => {
   const { config, logger } = context;
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
@@ -638,27 +718,35 @@ var getLocator = /* @__PURE__ */ __name(async (context) => {
     meterProvider,
     statusReporter
   }));
-  await registerChainRewardsClaimSentinel(locator, config, traceProvider, meterProvider, statusReporter);
+  const gateway = await getGateway(config);
+  const chainStepRewardsClaimSentinelParams = {
+    gateway,
+    traceProvider,
+    meterProvider,
+    statusReporter
+  };
+  locator.register(ChainStepRewardsClaimSentinel.factory(chainStepRewardsClaimSentinelParams));
+  const derivedAddressWalletTransferSentinelParams = {
+    gateway,
+    traceProvider,
+    meterProvider,
+    statusReporter
+  };
+  locator.register(DerivedAddressWalletTransferSentinel.factory(derivedAddressWalletTransferSentinelParams));
   return locator;
 }, "getLocator");
-var registerChainRewardsClaimSentinel = /* @__PURE__ */ __name(async (locator, config, traceProvider, meterProvider, statusReporter) => {
+var getGateway = /* @__PURE__ */ __name(async (config) => {
   const { mnemonic, chainRpcApiUrl: endpoint } = config.rewardRedemptionApi;
-  const walletPromise = isDefined7(mnemonic) ? HDWallet2.fromPhrase(mnemonic) : HDWallet2.random();
+  const walletPromise = isDefined7(mnemonic) ? HDWallet.fromPhrase(mnemonic) : HDWallet.random();
   const account = await walletPromise;
-  const signer = new MemoryXyoSigner2(account);
-  const connection = new HttpRpcXyoConnection2({
+  const signer = new MemoryXyoSigner(account);
+  const connection = new HttpRpcXyoConnection({
     endpoint,
     account
   });
-  const gateway = new MemoryXyoGateway2(signer, connection);
-  const chainRewardsClaimSentinelParams = {
-    gateway,
-    traceProvider,
-    meterProvider,
-    statusReporter
-  };
-  locator.register(ChainRewardsClaimSentinel.factory(chainRewardsClaimSentinelParams));
-}, "registerChainRewardsClaimSentinel");
+  const gateway = new MemoryXyoGateway(signer, connection);
+  return gateway;
+}, "getGateway");
 
 // src/manifest/getNode.ts
 import { ManifestWrapper } from "@xyo-network/manifest-wrapper";
@@ -692,30 +780,15 @@ var node_default = {
           {
             config: {
               accountPath: "1/1'/2'",
-              name: "ChainRewardsClaimSentinel",
-              schema: "network.xyo.sentinel.chain.rewards.claim.config"
+              name: "ChainStepRewardsClaimSentinel",
+              schema: "network.xyo.sentinel.chain.step.rewards.claim.config"
             }
           },
           {
             config: {
-              accountPath: "1/1'/3'",
-              automations: [
-                {
-                  frequency: 6e4,
-                  frequencyUnits: "millis",
-                  schema: "network.xyo.automation.interval",
-                  type: "interval"
-                }
-              ],
-              name: "ChainRewardsClaimIntervalSentinel",
-              schema: "network.xyo.sentinel.config",
-              synchronous: true,
-              tasks: [
-                {
-                  mod: "ChainRewardsClaimSentinel",
-                  endPoint: "report"
-                }
-              ]
+              accountPath: "1/1'/4'",
+              name: "DerivedAddressWalletTransferSentinel",
+              schema: "network.xyo.sentinel.chain.derived.address.wallet.transfer.config"
             }
           }
         ],
@@ -779,20 +852,20 @@ var getSeedPhrase = /* @__PURE__ */ __name(async (bios, config, logger) => {
     if (isString(mnemonic)) {
       seedPhrase = mnemonic;
     } else {
-      seedPhrase = HDWallet3.generateMnemonic();
+      seedPhrase = HDWallet2.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 assertEx4(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
+  return assertEx5(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 = isDefined8(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
-  const wallet = await HDWallet3.fromPhrase(seedPhrase);
+  const wallet = await HDWallet2.fromPhrase(seedPhrase);
   const nodeContext = {
     wallet,
     logger,