@xyo-network/xl1-protocol-sdk 1.15.9 → 1.15.11

package/dist/neutral/config/Config.d.ts

@@ -55,6 +55,11 @@ export declare const ConfigZod: z.ZodObject<{
         port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
         rewardAddress: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    rewardRedemptionApi: z.ZodDefault<z.ZodObject<{
+        host: z.ZodDefault<z.ZodString>;
+        mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
     storage: z.ZodDefault<z.ZodObject<{
         mongo: z.ZodOptional<z.ZodObject<{
             connectionString: z.ZodOptional<z.ZodString>;
@@ -70,6 +75,26 @@ export declare const ConfigZod: z.ZodObject<{
             otlpEndpoint: z.ZodOptional<z.ZodURL>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    validation: z.ZodDefault<z.ZodObject<{
+        allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, {
+            readonly __address: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, {
+            readonly __address: true;
+        }>, unknown>>>>>;
+        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, {
+            readonly __address: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, {
+            readonly __address: true;
+        }>, unknown>>>>>;
+    }, z.core.$strip>>;
     logLevel: z.ZodDefault<z.ZodEnum<{
         error: "error";
         warn: "warn";

package/dist/neutral/config/Config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../src/config/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAYxB,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAAmF,CAAA;AAErH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUpB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,eAAO,MAAM,gBAAgB,QAAO,MAA6B,CAAA"}
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../src/config/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAcxB,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAAmF,CAAA;AAErH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYpB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,eAAO,MAAM,gBAAgB,QAAO,MAA6B,CAAA"}

package/dist/neutral/config/RewardRedemptionApi.d.ts

@@ -0,0 +1,8 @@
+import * as z from 'zod';
+export declare const RewardRedemptionApiConfigZod: z.ZodObject<{
+    host: z.ZodDefault<z.ZodString>;
+    mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type RewardRedemptionApiConfig = z.infer<typeof RewardRedemptionApiConfigZod>;
+//# sourceMappingURL=RewardRedemptionApi.d.ts.map

package/dist/neutral/config/RewardRedemptionApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RewardRedemptionApi.d.ts","sourceRoot":"","sources":["../../../src/config/RewardRedemptionApi.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,4BAA4B;;;;iBAkBvC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA"}

package/dist/neutral/config/Validation.d.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+export declare const ValidationConfigZod: z.ZodObject<{
+    allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, unknown>>>>>;
+    allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, unknown>>>>>;
+}, z.core.$strip>;
+export type ValidationConfig = z.infer<typeof ValidationConfigZod>;
+//# sourceMappingURL=Validation.d.ts.map

package/dist/neutral/config/Validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Validation.d.ts","sourceRoot":"","sources":["../../../src/config/Validation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;iBAqB9B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/neutral/index.d.ts

@@ -8,6 +8,8 @@ export * from './map/index.ts';
 export * from './model/index.ts';
 export * from './multipliers.ts';
 export * from './payload/index.ts';
+export * from './primitives/index.ts';
+export * from './primitives/index.ts';
 export * from './SignedBigInt.ts';
 export * from './time/index.ts';
 export * from './transaction/index.ts';

package/dist/neutral/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,sBAAsB,CAAA;AACpC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,sBAAsB,CAAA;AACpC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mBAAmB,CAAA"}

package/dist/neutral/index.mjs

@@ -556,7 +556,7 @@ var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth =
 }, "tryHydrateBlock");
 
 // src/config/Config.ts
-import * as z12 from "zod";
+import * as z14 from "zod";
 
 // src/config/Api.ts
 import { globalRegistry } from "zod";
@@ -765,37 +765,60 @@ var ProducerConfigZod = z8.object({
   })
 });
 
-// src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined4, isUndefined } from "@xylabs/typeof";
+// src/config/RewardRedemptionApi.ts
 import { globalRegistry as globalRegistry8 } from "zod";
 import * as z9 from "zod";
+var RewardRedemptionApiConfigZod = z9.object({
+  host: z9.string().default("localhost").register(globalRegistry8, {
+    default: "localhost",
+    description: "Host for the Redemption API",
+    title: "rewardRedemptionApi.host",
+    type: "string"
+  }),
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry8, {
+    description: "Mnemonic for the Redemption API wallet",
+    title: "rewardRedemptionApi.mnemonic",
+    type: "string"
+  }),
+  port: z9.coerce.number().default(8082).register(globalRegistry8, {
+    default: 8082,
+    description: "Port for the Redemption API",
+    title: "rewardRedemptionApi.port",
+    type: "number"
+  })
+});
+
+// src/config/storage/driver/Mongo.ts
+import { isDefined as isDefined4, isUndefined } from "@xylabs/typeof";
+import { globalRegistry as globalRegistry9 } from "zod";
+import * as z10 from "zod";
 var hasMongoConfig = /* @__PURE__ */ __name((config) => {
   if (isUndefined(config)) return false;
   return isDefined4(config.connectionString) && isDefined4(config.database) && isDefined4(config.domain) && isDefined4(config.password) && isDefined4(config.username);
 }, "hasMongoConfig");
-var MongoConfigZod = z9.object({
+var MongoConfigZod = z10.object({
   // TODO: Create from other arguments
-  connectionString: z9.string().min(1).optional().register(globalRegistry8, {
+  connectionString: z10.string().min(1).optional().register(globalRegistry9, {
     description: "MongoDB connection string",
     title: "storage.mongo.connectionString",
     type: "string"
   }),
-  database: z9.string().min(1).optional().register(globalRegistry8, {
+  database: z10.string().min(1).optional().register(globalRegistry9, {
     description: "MongoDB database name",
     title: "storage.mongo.database",
     type: "string"
   }),
-  domain: z9.string().min(1).optional().register(globalRegistry8, {
+  domain: z10.string().min(1).optional().register(globalRegistry9, {
     description: "MongoDB domain",
     title: "storage.mongo.domain",
     type: "string"
   }),
-  password: z9.string().min(1).optional().register(globalRegistry8, {
+  password: z10.string().min(1).optional().register(globalRegistry9, {
     description: "MongoDB password",
     title: "storage.mongo.password",
     type: "string"
   }),
-  username: z9.string().min(1).optional().register(globalRegistry8, {
+  username: z10.string().min(1).optional().register(globalRegistry9, {
     description: "MongoDB username",
     title: "storage.mongo.username",
     type: "string"
@@ -803,11 +826,11 @@ var MongoConfigZod = z9.object({
 });
 
 // src/config/storage/Storage.ts
-import { globalRegistry as globalRegistry9 } from "zod";
-import * as z10 from "zod";
-var StorageConfigZod = z10.object({
+import { globalRegistry as globalRegistry10 } from "zod";
+import * as z11 from "zod";
+var StorageConfigZod = z11.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z10.string().optional().register(globalRegistry9, {
+  root: z11.string().optional().register(globalRegistry10, {
     description: "Root directory for local storage",
     title: "storage.root",
     type: "string"
@@ -815,26 +838,53 @@ var StorageConfigZod = z10.object({
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry10 } from "zod";
-import * as z11 from "zod";
-var OpenTelemetryConfigZod = z11.object({
+import { globalRegistry as globalRegistry11 } from "zod";
+import * as z12 from "zod";
+var OpenTelemetryConfigZod = z12.object({
   // OpenTelemetry options
-  otlpEndpoint: z11.url().optional().register(globalRegistry10, {
+  otlpEndpoint: z12.url().optional().register(globalRegistry11, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z11.object({
+var TelemetryConfigZod = z12.object({
   // OpenTelemetry configuration
   otel: OpenTelemetryConfigZod.optional().describe("OpenTelemetry configuration")
 }).describe("Telemetry configuration options");
 
+// src/config/Validation.ts
+import { AddressZod as AddressZod2, asAddress as asAddress4 } from "@xylabs/hex";
+import { globalRegistry as globalRegistry12 } from "zod";
+import * as z13 from "zod";
+var ValidationConfigZod = z13.object({
+  allowedRewardRedeemers: z13.preprocess((val) => {
+    if (typeof val === "string") {
+      return val.split(",").map((s) => asAddress4(s.trim()));
+    }
+    return val;
+  }, z13.array(AddressZod2).optional().register(globalRegistry12, {
+    description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
+    title: "allowedRewardRedeemers",
+    type: "array"
+  })),
+  allowedRewardEscrowAccountSigners: z13.preprocess((val) => {
+    if (typeof val === "string") {
+      return val.split(",").map((s) => asAddress4(s.trim()));
+    }
+    return val;
+  }, z13.array(AddressZod2).optional().register(globalRegistry12, {
+    description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
+    title: "allowedRewardEscrowAccountSigners",
+    type: "array"
+  }))
+});
+
 // src/config/Config.ts
-var Xl1CommonConfigSchema = z12.object({
+var Xl1CommonConfigSchema = z14.object({
   ...LogConfigZod.shape
 }).describe("XL1 common configuration options");
-var ConfigZod = z12.object({
+var ConfigZod = z14.object({
   ...Xl1CommonConfigSchema.shape,
   api: ApiConfigZod.default(ApiConfigZod.parse({})).describe("Configuration for the API node"),
   app: AppConfigZod.default(AppConfigZod.parse({})).describe("Configuration for the application"),
@@ -842,41 +892,43 @@ var ConfigZod = z12.object({
   chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe("Configuration for the chain"),
   evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe("Configuration for EVM-backed services"),
   producer: ProducerConfigZod.default(ProducerConfigZod.parse({})).describe("Configuration for the producer"),
+  rewardRedemptionApi: RewardRedemptionApiConfigZod.default(RewardRedemptionApiConfigZod.parse({})).describe("Configuration for the rewards redemption API"),
   storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe("Configuration for the storage"),
-  telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe("Configuration for telemetry")
+  telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe("Configuration for telemetry"),
+  validation: ValidationConfigZod.default(ValidationConfigZod.parse({})).describe("Configuration for validation")
 });
 var getDefaultConfig = /* @__PURE__ */ __name(() => ConfigZod.parse({}), "getDefaultConfig");
 
 // src/config/UsageMeta.ts
-import * as z13 from "zod";
-var DescriptionSchema = z13.string();
-var TitleSchema = z13.string();
-var JSONSchemaMetaSchema = z13.object({
-  id: z13.string().optional(),
+import * as z15 from "zod";
+var DescriptionSchema = z15.string();
+var TitleSchema = z15.string();
+var JSONSchemaMetaSchema = z15.object({
+  id: z15.string().optional(),
   title: TitleSchema.optional(),
   description: DescriptionSchema.optional(),
-  deprecated: z13.boolean().optional()
-}).catchall(z13.unknown());
+  deprecated: z15.boolean().optional()
+}).catchall(z15.unknown());
 var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
-var ChoicesSchema = z13.array(z13.union([
-  z13.string(),
-  z13.number(),
-  z13.literal(true),
-  z13.undefined()
+var ChoicesSchema = z15.array(z15.union([
+  z15.string(),
+  z15.number(),
+  z15.literal(true),
+  z15.undefined()
 ])).readonly();
 var UsageMetaSchema = GlobalMetaSchema.extend({
   choices: ChoicesSchema.optional(),
-  default: z13.unknown().optional(),
+  default: z15.unknown().optional(),
   description: DescriptionSchema,
-  group: z13.string().optional(),
-  hidden: z13.boolean().optional(),
+  group: z15.string().optional(),
+  hidden: z15.boolean().optional(),
   title: TitleSchema,
-  type: z13.union([
-    z13.literal("array"),
-    z13.literal("count"),
-    z13.literal("boolean"),
-    z13.literal("number"),
-    z13.literal("string")
+  type: z15.union([
+    z15.literal("array"),
+    z15.literal("count"),
+    z15.literal("boolean"),
+    z15.literal("number"),
+    z15.literal("string")
   ])
 });
 function isUsageMeta(v) {
@@ -896,18 +948,98 @@ var StakeEventNames = [
 ];
 
 // src/multipliers.ts
-import { asAttoXL1, asXL1, XL1Amount } from "@xyo-network/xl1-protocol";
-var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_REWARDS = asAttoXL1(1105508843867301885042548n);
-var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS = XL1Amount.fromXL1(asXL1(100000000n)).atto;
+import { asAttoXL1 } from "@xyo-network/xl1-protocol";
+var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS = asAttoXL1(1105508843867301885042548n);
+var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS = asAttoXL1(100000000000000000000000000n);
+var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_REWARDS = XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS + XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS;
 var RewardMultipliers = {
   [`0|${XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK}`]: [
     XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS,
-    XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_REWARDS
+    XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS
   ]
 };
 
-// src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
+// src/primitives/step/completedStepRewardAddress.ts
+import { toAddress as toAddress2 } from "@xylabs/hex";
+import { keccak256 } from "ethers";
+function completedStepRewardAddress({ block, step }) {
+  const addressKey = new TextEncoder().encode(`${block}|${step}`);
+  return toAddress2(keccak256(addressKey).slice(-40), {
+    prefix: false
+  });
+}
+__name(completedStepRewardAddress, "completedStepRewardAddress");
+
+// src/primitives/step/derivedReceiveAddress.ts
+import { toAddress as toAddress3 } from "@xylabs/hex";
+import { isDefined as isDefined5 } from "@xylabs/typeof";
+import { keccak256 as keccak2562 } from "ethers";
+function derivedReceiveAddress(address, scope) {
+  const addressKey = new TextEncoder().encode(isDefined5(scope) ? `${scope}|${address}` : address);
+  return toAddress3(keccak2562(addressKey).slice(-40), {
+    prefix: false
+  });
+}
+__name(derivedReceiveAddress, "derivedReceiveAddress");
+
+// src/primitives/step/stepBlockRange.ts
+import { asXL1BlockRange, StepSizes as StepSizes5 } from "@xyo-network/xl1-protocol";
+function stepBlockRange({ block, step }) {
+  const stepSize2 = StepSizes5[step];
+  const start = block - stepSize2;
+  return asXL1BlockRange([
+    start,
+    start + stepSize2 - 1
+  ]);
+}
+__name(stepBlockRange, "stepBlockRange");
+
+// src/primitives/step/stepTransferIndex.ts
 import { assertEx as assertEx6 } from "@xylabs/assert";
+import { StepSizes as StepSizes6 } from "@xyo-network/xl1-protocol";
+function stepTransferIndex(block, step) {
+  let rewardTransferCount = 0;
+  let rewardTransferIndex = -1;
+  for (let i = 3; i < StepSizes6.length; i++) {
+    const stepSize2 = StepSizes6[i];
+    if (block % stepSize2 === 0) {
+      if (stepSize2 === StepSizes6[step]) {
+        rewardTransferIndex = rewardTransferCount;
+      }
+      rewardTransferCount++;
+    }
+  }
+  assertEx6(rewardTransferIndex >= 0, () => `Error: Could not find step size for step ${step} at block ${block}`);
+  return [
+    rewardTransferIndex,
+    rewardTransferCount
+  ];
+}
+__name(stepTransferIndex, "stepTransferIndex");
+
+// src/primitives/transaction/elevatedPayloads.ts
+import { isAllowedBlockPayload } from "@xyo-network/xl1-protocol";
+function elevatedPayloads([tx, payloads]) {
+  const opCodes = (tx.script ?? []).filter((operation) => operation.startsWith("elevate|"));
+  const elevatedPayloads2 = [];
+  for (const opCode of opCodes) {
+    const [code, hash] = opCode.split("|");
+    if (code === "elevated") {
+      const elevatedPayload = payloads.find((payload) => payload._hash === hash);
+      if (isAllowedBlockPayload(elevatedPayload)) {
+        elevatedPayloads2.push(elevatedPayload);
+      }
+    }
+  }
+  if (opCodes.length === elevatedPayloads2.length) {
+    return elevatedPayloads2;
+  }
+  throw new Error("Not all elevated payloads could be found in the transaction payloads");
+}
+__name(elevatedPayloads, "elevatedPayloads");
+
+// src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
+import { assertEx as assertEx7 } from "@xylabs/assert";
 import { asTimePayload, TimeSchema } from "@xyo-network/xl1-protocol";
 async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
@@ -915,12 +1047,12 @@ async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const timePayload = asTimePayload(hydratedBlock[1].find((p) => p.schema === TimeSchema), {
     required: true
   });
-  return assertEx6(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx7(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 __name(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
 
 // src/transaction/buildTransaction.ts
-import { assertEx as assertEx7 } from "@xylabs/assert";
+import { assertEx as assertEx8 } from "@xylabs/assert";
 import { toHex as toHex2 } from "@xylabs/hex";
 import { BoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
 import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
@@ -947,7 +1079,7 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
   }
   const fields = {
     ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx7(signer.at(0)?.address) : signer.address)
+    from: from ?? (Array.isArray(signer) ? assertEx8(signer.at(0)?.address) : signer.address)
   };
   if (script.length > 0) {
     fields.script = script;
@@ -1011,7 +1143,7 @@ __name(buildUnsignedTransaction, "buildUnsignedTransaction");
 
 // src/transaction/confirmSubmittedTransaction.ts
 import { delay } from "@xylabs/delay";
-import { isDefined as isDefined5 } from "@xylabs/typeof";
+import { isDefined as isDefined6 } from "@xylabs/typeof";
 import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
@@ -1022,7 +1154,7 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transact
   let attempts = 0;
   while (true) {
     const tx = await viewer.transactionByHash(txBWHash) ?? void 0;
-    if (isDefined5(tx)) {
+    if (isDefined6(tx)) {
       options?.logger?.log("\u2705 Transaction confirmed:", txBWHash, "\n");
       return tx;
     } else {
@@ -1039,9 +1171,9 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transact
 }, "confirmSubmittedTransaction");
 
 // src/transaction/hydrateTransaction.ts
-import { assertEx as assertEx8 } from "@xylabs/assert";
+import { assertEx as assertEx9 } from "@xylabs/assert";
 import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from "@xyo-network/archivist-model";
-import { isAllowedBlockPayload, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { isAllowedBlockPayload as isAllowedBlockPayload2, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var tryHydrateTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
   return await tryHydrateTypedBoundWitness({
     get(hashes) {
@@ -1079,26 +1211,26 @@ var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async ({ chainMap },
   }
   const [transaction, payloads] = hydratedTransaction;
   const opCodes = (transaction.script ?? []).filter((operation) => operation.startsWith("elevate|"));
-  const elevatedPayloads = [];
+  const elevatedPayloads2 = [];
   for (const opCode of opCodes) {
     const [code, hash2] = opCode.split("|");
     if (code === "elevated") {
       const elevatedPayload = payloads.find((payload) => payload._hash === hash2);
-      if (isAllowedBlockPayload(elevatedPayload)) {
-        elevatedPayloads.push(elevatedPayload);
+      if (isAllowedBlockPayload2(elevatedPayload)) {
+        elevatedPayloads2.push(elevatedPayload);
       }
     }
   }
-  if (opCodes.length === elevatedPayloads.length) {
+  if (opCodes.length === elevatedPayloads2.length) {
     return [
       transaction,
-      elevatedPayloads
+      elevatedPayloads2
     ];
   }
   return void 0;
 }, "tryHydrateElevatedTransaction");
 var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (context, hash) => {
-  return assertEx8(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
+  return assertEx9(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
 }, "hydrateElevatedTransaction");
 
 // src/transaction/primitives/transactionBlockByteCount.ts
@@ -1139,8 +1271,8 @@ function transactionElevatedPayloadHashes(transaction) {
 __name(transactionElevatedPayloadHashes, "transactionElevatedPayloadHashes");
 function transactionElevatedPayloads([transaction, payloads]) {
   const hashes = transactionElevatedPayloadHashes(transaction);
-  const elevatedPayloads = payloads.filter((payload) => hashes.includes(payload._hash));
-  return elevatedPayloads;
+  const elevatedPayloads2 = payloads.filter((payload) => hashes.includes(payload._hash));
+  return elevatedPayloads2;
 }
 __name(transactionElevatedPayloads, "transactionElevatedPayloads");
 
@@ -1155,16 +1287,16 @@ function transactionBytesRequiredGas([transaction, payloads]) {
 }
 __name(transactionBytesRequiredGas, "transactionBytesRequiredGas");
 function transactionRequiredGas(hydratedTransaction) {
-  const elevatedPayloads = transactionElevatedPayloads(hydratedTransaction);
-  const hashes = elevatedPayloads.length + 1;
+  const elevatedPayloads2 = transactionElevatedPayloads(hydratedTransaction);
+  const hashes = elevatedPayloads2.length + 1;
   const signatures = hydratedTransaction[0].addresses.length;
-  return AttoXL1(transactionBytesRequiredGas(hydratedTransaction) + TransactionGasCosts.hashValidation * BigInt(hashes) + TransactionGasCosts.signatureValidation * BigInt(signatures) + TransactionGasCosts.payloadValidation * BigInt(elevatedPayloads.length));
+  return AttoXL1(transactionBytesRequiredGas(hydratedTransaction) + TransactionGasCosts.hashValidation * BigInt(hashes) + TransactionGasCosts.signatureValidation * BigInt(signatures) + TransactionGasCosts.payloadValidation * BigInt(elevatedPayloads2.length));
 }
 __name(transactionRequiredGas, "transactionRequiredGas");
 
 // src/transaction/script.ts
 import { filterAs as filterAs2 } from "@xylabs/array";
-import { assertEx as assertEx9 } from "@xylabs/assert";
+import { assertEx as assertEx10 } from "@xylabs/assert";
 import { asHash as asHash3 } from "@xylabs/hex";
 import { isAllowedBlockPayloadWithHashStorageMeta } from "@xyo-network/xl1-protocol";
 var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
@@ -1174,7 +1306,7 @@ var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
 var extractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
   const filtered = filterAs2(hashes, (h) => asHash3(h));
-  assertEx9(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx10(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashesFromScript");
 var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
@@ -1188,17 +1320,17 @@ var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
   const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashStorageMeta);
-  assertEx9(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx10(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashes");
 
 // src/transaction/signTransaction.ts
 import { toArrayBuffer } from "@xylabs/arraybuffer";
-import { assertEx as assertEx10 } from "@xylabs/assert";
+import { assertEx as assertEx11 } from "@xylabs/assert";
 import { hexFromArrayBuffer } from "@xylabs/hex";
 import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 async function signTransaction(tx, account) {
-  assertEx10(tx.from === account.address, () => "Signer address does not match transaction from address");
+  assertEx11(tx.from === account.address, () => "Signer address does not match transaction from address");
   const signedTx = structuredClone(tx);
   signedTx.addresses = [
     account.address
@@ -1264,6 +1396,7 @@ export {
   XL1_NETWORK_STAKING_GENESIS_PERIOD_END_EPOCH,
   XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK,
   XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS,
+  XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS,
   XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_REWARDS,
   Xl1CommonConfigSchema,
   allHashesPresent,
@@ -1278,10 +1411,13 @@ export {
   buildTransaction,
   buildUnsignedTransaction,
   calculateFramesFromRange,
+  completedStepRewardAddress,
   confirmSubmittedTransaction,
   crackOperation,
   crackOperations,
   deepCalculateFramesFromRange,
+  derivedReceiveAddress,
+  elevatedPayloads,
   extractElevatedHashes,
   extractElevatedHashesFromScript,
   flattenHydratedBlock,
@@ -1310,6 +1446,8 @@ export {
   parseSignedBigInt,
   readPayloadMapFromStore,
   signTransaction,
+  stepBlockRange,
+  stepTransferIndex,
   toPositiveBigInt,
   toSignedBigInt,
   transactionBlockByteCount,