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

package/dist/node/index.mjs

@@ -112,14 +112,14 @@ var addDataLakeRoutes = /* @__PURE__ */ __name((app) => {
 }, "addDataLakeRoutes");
 
 // 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/ChainStepRewardsClaimSentinel/ChainStepRewardsClaimSentinel.ts
 import { assertEx } from "@xylabs/assert";
@@ -131,6 +131,23 @@ import { asXL1BlockNumber, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-prot
 import { completedStepRewardAddress, derivedReceiveAddress, flattenHydratedTransaction, flattenHydratedTransactions } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex } from "async-mutex";
 
+// 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";
@@ -141,6 +158,8 @@ var asStepIdentityPayload = AsObjectFactory.create(isStepIdentityPayload);
 
 // 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 RewardableSteps = [
   3,
@@ -261,9 +280,9 @@ var ChainStepRewardsClaimSentinel = 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}`);
@@ -295,20 +314,131 @@ var ChainStepRewardsClaimSentinel = class extends AbstractSentinel {
   }
 };
 
+// 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 isDefined3, isPromise } from "@xylabs/typeof";
+import { isDefined as isDefined4, 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())
+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: z.json().optional(),
-  response: z.json().optional()
+  body: z2.json().optional(),
+  response: z2.json().optional()
 };
 function requestHandlerValidator(schemas) {
   const validators = {
@@ -329,7 +459,7 @@ function requestHandlerValidator(schemas) {
           const validator = validators[key];
           const result2 = validator.safeParse(req[key]);
           if (result2.success) {
-            if (isDefined3(result2.data)) Object.assign(req[key], result2.data);
+            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}`));
           }
@@ -369,11 +499,11 @@ function requestHandlerValidator(schemas) {
 __name(requestHandlerValidator, "requestHandlerValidator");
 
 // src/server/routes/rewardRedemption/routeDefinitions/util/getViewerFromConfig.ts
-import { isDefined as isDefined4 } from "@xylabs/typeof";
+import { isDefined as isDefined5 } 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 (isDefined5(viewer)) return viewer;
   const transport = new HttpRpcTransport(config.rewardRedemptionApi.chainRpcApiUrl, XyoViewerRpcSchemas);
   viewer = new JsonRpcXyoViewer(transport);
   return viewer;
@@ -390,12 +520,12 @@ var RewardableSteps2 = [
 ];
 
 // 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(...RewardableSteps2)).max(Math.max(...RewardableSteps2)).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
@@ -403,18 +533,18 @@ var validateRequest = requestHandlerValidator({
 var getChainStepRewardsClaimSentinel = /* @__PURE__ */ __name(async (node) => {
   const mod = await node.resolve("XYORewardRedemptionNode:ChainStepRewardsClaimSentinel");
   const sentinel = asSentinelInstance(mod);
-  return assertEx2(sentinel, () => "ChainStepRewardsClaimSentinel not found on node");
+  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([]);
@@ -444,12 +574,16 @@ var postClaimRange = {
 };
 
 // src/server/routes/rewardRedemption/routeDefinitions/routes/redeem.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
-import { PayloadZodLoose as PayloadZodLoose2 } from "@xyo-network/payload-model";
+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 { z as z3 } from "zod";
-var body = z3.array(PayloadZodLoose2);
-var response2 = z3.array(PayloadZodLoose2);
+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
@@ -457,7 +591,7 @@ var validateRequest2 = requestHandlerValidator({
 var getDerivedAddressWalletTransferSentinel = /* @__PURE__ */ __name(async (node) => {
   const mod = await node.resolve("XYORewardRedemptionNode:DerivedAddressWalletTransferSentinel");
   const sentinel = asSentinelInstance2(mod);
-  return assertEx3(sentinel, () => "DerivedAddressWalletTransferSentinel not found on node");
+  return assertEx4(sentinel, () => "DerivedAddressWalletTransferSentinel not found on node");
 }, "getDerivedAddressWalletTransferSentinel");
 var postRedeem = {
   method: "post",
@@ -465,9 +599,8 @@ var postRedeem = {
   handlers: validateRequest2(async (req, res) => {
     const { node } = req.app;
     const { body: body2 } = req;
-    const input = body2;
     const sentinel = await getDerivedAddressWalletTransferSentinel(node);
-    const result = await sentinel.report(input);
+    const result = await sentinel.report(body2);
     res.status(200);
     res.json(result);
   })
@@ -518,13 +651,13 @@ var getApp = /* @__PURE__ */ __name((node, config) => {
 }, "getApp");
 
 // src/server/server.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
-import { isDefined as isDefined7, isString } from "@xylabs/typeof";
+import { assertEx as assertEx5 } 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";
 
 // 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";
@@ -549,7 +682,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;
@@ -585,12 +718,26 @@ 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 = isDefined6(mnemonic) ? HDWallet.fromPhrase(mnemonic) : HDWallet.random();
+  const walletPromise = isDefined7(mnemonic) ? HDWallet.fromPhrase(mnemonic) : HDWallet.random();
   const account = await walletPromise;
   const signer = new MemoryXyoSigner(account);
   const connection = new HttpRpcXyoConnection({
@@ -598,14 +745,8 @@ var registerChainRewardsClaimSentinel = /* @__PURE__ */ __name(async (locator, c
     account
   });
   const gateway = new MemoryXyoGateway(signer, connection);
-  const chainStepRewardsClaimSentinelParams = {
-    gateway,
-    traceProvider,
-    meterProvider,
-    statusReporter
-  };
-  locator.register(ChainStepRewardsClaimSentinel.factory(chainStepRewardsClaimSentinelParams));
-}, "registerChainRewardsClaimSentinel");
+  return gateway;
+}, "getGateway");
 
 // src/manifest/getNode.ts
 import { ManifestWrapper } from "@xyo-network/manifest-wrapper";
@@ -645,24 +786,9 @@ var node_default = {
           },
           {
             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: "ChainStepRewardsClaimSentinel",
-                  endPoint: "report"
-                }
-              ]
+              accountPath: "1/1'/4'",
+              name: "DerivedAddressWalletTransferSentinel",
+              schema: "network.xyo.sentinel.chain.derived.address.wallet.transfer.config"
             }
           }
         ],
@@ -732,13 +858,13 @@ var getSeedPhrase = /* @__PURE__ */ __name(async (bios, config, logger) => {
     }
     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 = isDefined7(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
+  const seedPhrase = isDefined8(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
   const wallet = await HDWallet2.fromPhrase(seedPhrase);
   const nodeContext = {
     wallet,