@xyo-network/xl1-protocol-sdk 1.14.4 → 1.15.0

package/dist/neutral/index.mjs

@@ -1,33 +1,56 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// src/block/hydrateBlock.ts
-import { filterAs } from "@xylabs/array";
-import { assertEx } from "@xylabs/assert";
-import { asTransactionBoundWitnessWithStorageMeta, isBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+// src/block/hydrate/allHashesPresent.ts
 function allHashesPresent(hashes, payloads) {
   const payloadHashes = new Set(payloads.map((p) => p._hash));
   return hashes.every((hash) => payloadHashes.has(hash));
 }
 __name(allHashesPresent, "allHashesPresent");
-var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1) => {
-  assertEx(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
-  const bw = (await archivist.get([
+
+// src/block/hydrate/blockPayloadsFromHydratedBlock.ts
+import { assertEx } from "@xylabs/assert";
+import { isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+var blockPayloadsFromHydratedBlock = /* @__PURE__ */ __name((block) => {
+  return block[0].payload_hashes.map((hash) => assertEx(block[1].find((p) => p._hash === hash), () => `missing payload ${hash}`)).filter((x) => !isTransactionBoundWitnessWithStorageMeta(x));
+}, "blockPayloadsFromHydratedBlock");
+
+// src/block/hydrate/flattenHydratedBlock.ts
+var flattenHydratedBlock = /* @__PURE__ */ __name((hydratedBlock) => {
+  const [blk, blkPayloads] = hydratedBlock;
+  return [
+    ...blkPayloads,
+    blk
+  ];
+}, "flattenHydratedBlock");
+
+// src/block/hydrate/flattenHydratedBlocks.ts
+var flattenHydratedBlocks = /* @__PURE__ */ __name((hydratedBlocks) => hydratedBlocks.flatMap((blk) => flattenHydratedBlock(blk)), "flattenHydratedBlocks");
+
+// src/block/hydrate/hydrateBlock.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { isBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta as isTransactionBoundWitnessWithStorageMeta2 } from "@xyo-network/xl1-protocol";
+var hydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1, minDepth = maxDepth) => {
+  assertEx2(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
+  assertEx2(minDepth >= 0, () => "minDepth must be greater than or equal to 0");
+  assertEx2(maxDepth >= minDepth, () => "maxDepth must be greater than or equal to minDepth");
+  const bw = assertEx2((await archivist.get([
     hash
-  ])).find(isBlockBoundWitnessWithStorageMeta);
-  if (!bw) return void 0;
+  ])).find(isBlockBoundWitnessWithStorageMeta), () => `block ${hash} not found`);
   if (maxDepth === 0) return [
     bw,
     []
   ];
   const blkPayloads = await archivist.get(bw.payload_hashes);
+  if (minDepth === 1) assertEx2(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`);
   if (maxDepth === 1) return [
     bw,
     blkPayloads
   ];
-  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
+  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta2);
   const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
   const transactionsPayloads = await archivist.get(transactionsPayloadHashes);
+  assertEx2(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
   const allPayloadsHashes = new Set([
     ...blkPayloads,
     ...transactionsPayloads
@@ -36,32 +59,43 @@ var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth =
     ...allPayloadsHashes
   ]);
   const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
+  if (maxDepth === 2) assertEx2(allHashesPresent([
+    ...allPayloadsHashes
+  ], allPayloadsFiltered), () => `Unable to find all payloads for transactions in block ${hash}`);
   return [
     bw,
     allPayloadsFiltered
   ];
-}, "tryHydrateBlock");
-var hydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1, minDepth = maxDepth) => {
-  assertEx(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
-  assertEx(minDepth >= 0, () => "minDepth must be greater than or equal to 0");
-  assertEx(maxDepth >= minDepth, () => "maxDepth must be greater than or equal to minDepth");
-  const bw = assertEx((await archivist.get([
+}, "hydrateBlock");
+
+// src/block/hydrate/transactionsFromHydratedBlock.ts
+import { filterAs } from "@xylabs/array";
+import { asTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+var transactionsFromHydratedBlock = /* @__PURE__ */ __name((block) => {
+  return filterAs(block[1], asTransactionBoundWitnessWithStorageMeta);
+}, "transactionsFromHydratedBlock");
+
+// src/block/hydrate/tryHydrateBlock.ts
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { isBlockBoundWitnessWithStorageMeta as isBlockBoundWitnessWithStorageMeta2, isTransactionBoundWitnessWithStorageMeta as isTransactionBoundWitnessWithStorageMeta3 } from "@xyo-network/xl1-protocol";
+var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1) => {
+  assertEx3(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
+  const bw = (await archivist.get([
     hash
-  ])).find(isBlockBoundWitnessWithStorageMeta), () => `block ${hash} not found`);
+  ])).find(isBlockBoundWitnessWithStorageMeta2);
+  if (!bw) return void 0;
   if (maxDepth === 0) return [
     bw,
     []
   ];
   const blkPayloads = await archivist.get(bw.payload_hashes);
-  if (minDepth === 1) assertEx(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`);
   if (maxDepth === 1) return [
     bw,
     blkPayloads
   ];
-  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
+  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta3);
   const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
   const transactionsPayloads = await archivist.get(transactionsPayloadHashes);
-  assertEx(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
   const allPayloadsHashes = new Set([
     ...blkPayloads,
     ...transactionsPayloads
@@ -70,31 +104,14 @@ var hydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1,
     ...allPayloadsHashes
   ]);
   const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
-  if (maxDepth === 2) assertEx(allHashesPresent([
-    ...allPayloadsHashes
-  ], allPayloadsFiltered), () => `Unable to find all payloads for transactions in block ${hash}`);
   return [
     bw,
     allPayloadsFiltered
   ];
-}, "hydrateBlock");
-var flattenHydratedBlock = /* @__PURE__ */ __name((hydratedBlock) => {
-  const [blk, blkPayloads] = hydratedBlock;
-  return [
-    ...blkPayloads,
-    blk
-  ];
-}, "flattenHydratedBlock");
-var flattenHydratedBlocks = /* @__PURE__ */ __name((hydratedBlocks) => hydratedBlocks.flatMap((blk) => flattenHydratedBlock(blk)), "flattenHydratedBlocks");
-var transactionsFromHydratedBlock = /* @__PURE__ */ __name((block) => {
-  return filterAs(block[1], asTransactionBoundWitnessWithStorageMeta);
-}, "transactionsFromHydratedBlock");
-var blockPayloadsFromHydratedBlock = /* @__PURE__ */ __name((block) => {
-  return block[0].payload_hashes.map((hash) => assertEx(block[1].find((p) => p._hash === hash), () => `missing payload ${hash}`)).filter((x) => !isTransactionBoundWitnessWithStorageMeta(x));
-}, "blockPayloadsFromHydratedBlock");
+}, "tryHydrateBlock");
 
-// src/block/primitives/balanceStepSummaryFromRange.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
+// src/block/primitives/balances/balancesStepSummaryFromRange.ts
+import { assertEx as assertEx4 } from "@xylabs/assert";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { isAnyPayload } from "@xyo-network/payload-model";
 import { StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol";
@@ -119,8 +136,36 @@ var netBalancesForPayloads = /* @__PURE__ */ __name((payloads) => {
   });
 }, "netBalancesForPayloads");
 
+// src/payload/netTransfersForPayloads.ts
+import { hexToBigInt as hexToBigInt2 } from "@xylabs/hex";
+import { span as span2 } from "@xylabs/telemetry";
+import { isTransfer as isTransfer2 } from "@xyo-network/xl1-protocol";
+function netTransfersForPayloads(payloads, account) {
+  return span2("netTransfersForPayloads", () => {
+    const transfers = {};
+    for (const payload of payloads) {
+      if (isTransfer2(payload)) {
+        const { from } = payload;
+        for (let [address, amount] of Object.entries(payload.transfers)) {
+          if (account === from) {
+            if (address !== from) {
+              transfers[address] = (transfers[address] ?? 0n) + hexToBigInt2(amount);
+            }
+          } else {
+            if (account === address) {
+              transfers[from] = (transfers[from] ?? 0n) - hexToBigInt2(amount);
+            }
+          }
+        }
+      }
+    }
+    return transfers;
+  });
+}
+__name(netTransfersForPayloads, "netTransfersForPayloads");
+
 // src/SignedBigInt.ts
-import { hexToBigInt as hexToBigInt2, toHex } from "@xylabs/hex";
+import { hexToBigInt as hexToBigInt3, toHex } from "@xylabs/hex";
 import { isObject } from "@xylabs/object";
 var isNegativeBigInt = /* @__PURE__ */ __name((value) => {
   return isObject(value) && "negative" in value && typeof value.negative === "string";
@@ -130,9 +175,9 @@ var isPositiveBigInt = /* @__PURE__ */ __name((value) => {
 }, "isPositiveBigInt");
 var parseSignedBigInt = /* @__PURE__ */ __name((value) => {
   if (isNegativeBigInt(value)) {
-    return -hexToBigInt2(value.negative);
+    return -hexToBigInt3(value.negative);
   } else if (isPositiveBigInt(value)) {
-    return hexToBigInt2(value.positive);
+    return hexToBigInt3(value.positive);
   } else {
     throw new Error("Invalid balance type");
   }
@@ -225,11 +270,11 @@ function deepCalculateFramesFromRange(range, startingStep = StepSizes.length - 1
 }
 __name(deepCalculateFramesFromRange, "deepCalculateFramesFromRange");
 
-// src/block/primitives/hashFromBlockNumber.ts
+// src/block/primitives/blockFromBlockNumber.ts
 import { asHash } from "@xylabs/hex";
 import { toSafeJsonString } from "@xylabs/object";
 import { asBlockBoundWitnessWithStorageMeta, StepSizes as StepSizes2 } from "@xyo-network/xl1-protocol";
-async function hashFromBlockNumber(context, blockNumber) {
+async function blockFromBlockNumber(context, blockNumber) {
   const result = await context.chainArchivist.get([
     context.head
   ]);
@@ -259,14 +304,19 @@ async function hashFromBlockNumber(context, blockNumber) {
       throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${context.head}.`);
     }
   }
-  return currentBlock._hash;
+  return currentBlock;
+}
+__name(blockFromBlockNumber, "blockFromBlockNumber");
+
+// src/block/primitives/hashFromBlockNumber.ts
+async function hashFromBlockNumber(context, blockNumber) {
+  return (await blockFromBlockNumber(context, blockNumber))._hash;
 }
 __name(hashFromBlockNumber, "hashFromBlockNumber");
 
-// src/block/primitives/payloads.ts
+// src/block/primitives/payloads/BalancesStepSummary.ts
 import { AsObjectFactory } from "@xylabs/object";
 import { isPayloadOfSchemaType, isStorageMeta } from "@xyo-network/payload-model";
-var StepSummarySchema = "network.xyo.step.summary";
 var BalancesStepSummarySchema = "network.xyo.step.summary.balances";
 var isBalancesStepSummary = isPayloadOfSchemaType(BalancesStepSummarySchema);
 var asBalancesStepSummary = AsObjectFactory.create(isBalancesStepSummary);
@@ -275,8 +325,22 @@ var isBalancesStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
 }, "isBalancesStepSummaryWithStorageMeta");
 var asBalancesStepSummaryWithStorageMeta = AsObjectFactory.create(isBalancesStepSummaryWithStorageMeta);
 
-// src/block/primitives/balanceStepSummaryFromRange.ts
-async function balanceStepSummaryFromRange(context, range) {
+// src/block/primitives/payloads/StepSummary.ts
+var StepSummarySchema = "network.xyo.step.summary";
+
+// src/block/primitives/payloads/TransfersSummary.ts
+import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/object";
+import { isPayloadOfSchemaType as isPayloadOfSchemaType2, isStorageMeta as isStorageMeta2 } from "@xyo-network/payload-model";
+var TransfersStepSummarySchema = "network.xyo.step.summary.transfer";
+var isTransfersStepSummary = isPayloadOfSchemaType2(TransfersStepSummarySchema);
+var asTransfersStepSummary = AsObjectFactory2.create(isTransfersStepSummary);
+var isTransfersStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
+  return isTransfersStepSummary(value) && isStorageMeta2(value);
+}, "isTransfersStepSummaryWithStorageMeta");
+var asTransfersStepSummaryWithStorageMeta = AsObjectFactory2.create(isTransfersStepSummaryWithStorageMeta);
+
+// src/block/primitives/balances/balancesStepSummaryFromRange.ts
+async function balancesStepSummaryFromRange(context, range) {
   const frameHeadHash = await hashFromBlockNumber(context, range[1]);
   const frameSize = range[1] - range[0] + 1;
   let result = void 0;
@@ -295,7 +359,7 @@ async function balanceStepSummaryFromRange(context, range) {
     };
   } else {
     const step = StepSizes3.indexOf(frameSize);
-    assertEx2(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes3.join(", ")}`);
+    assertEx4(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes3.join(", ")}`);
     const [summaryResult] = await context.summaryRepository.get([
       frameHeadHash
     ]);
@@ -303,7 +367,7 @@ async function balanceStepSummaryFromRange(context, range) {
       result = summaryResult;
     } else {
       const subRanges = deepCalculateFramesFromRange(range, step - 1);
-      const promises = subRanges.map((subRange) => balanceStepSummaryFromRange(context, subRange));
+      const promises = subRanges.map((subRange) => balancesStepSummaryFromRange(context, subRange));
       const subResults = await Promise.all(promises);
       const bigIntBalances = {};
       for (const subResult of subResults) {
@@ -329,14 +393,14 @@ async function balanceStepSummaryFromRange(context, range) {
   const finalResult = await PayloadBuilder.addStorageMeta(result);
   return finalResult;
 }
-__name(balanceStepSummaryFromRange, "balanceStepSummaryFromRange");
+__name(balancesStepSummaryFromRange, "balancesStepSummaryFromRange");
 
-// src/block/primitives/balanceSummary.ts
+// src/block/primitives/balances/balancesSummary.ts
 import { asAddress } from "@xylabs/hex";
 import { spanRootAsync } from "@xylabs/telemetry";
 import { isDefined } from "@xylabs/typeof";
 import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2 } from "@xyo-network/xl1-protocol";
-async function balanceSummary(context) {
+async function balancesSummary(context) {
   return await spanRootAsync("balanceSummary", async () => {
     const headResult = await context.chainArchivist.get([
       context.head
@@ -349,7 +413,7 @@ async function balanceSummary(context) {
       rangeStart,
       headBoundWitness.block
     ]);
-    const summaries = await Promise.all(ranges.map((range) => balanceStepSummaryFromRange(context, range)));
+    const summaries = await Promise.all(ranges.map((range) => balancesStepSummaryFromRange(context, range)));
     const balances = {};
     for (let summary of summaries) {
       for (const [address, balance] of Object.entries(summary.balances)) {
@@ -360,7 +424,101 @@ async function balanceSummary(context) {
     return balances;
   });
 }
-__name(balanceSummary, "balanceSummary");
+__name(balancesSummary, "balancesSummary");
+
+// src/block/primitives/transfers/transfersStepSummaryFromRange.ts
+import { assertEx as assertEx5 } from "@xylabs/assert";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { isAnyPayload as isAnyPayload2 } from "@xyo-network/payload-model";
+import { StepSizes as StepSizes4 } from "@xyo-network/xl1-protocol";
+async function transfersStepSummaryFromRange(context, range) {
+  const frameHeadHash = await hashFromBlockNumber(context, range[1]);
+  const frameSize = range[1] - range[0] + 1;
+  const { account } = context;
+  let result = void 0;
+  if (frameSize === 1) {
+    const hash = await hashFromBlockNumber(context, range[0]);
+    const [, payloads] = await hydrateBlock(context.chainArchivist, hash);
+    const transfers = {};
+    for (const [address, balance] of Object.entries(netTransfersForPayloads(payloads, account))) {
+      transfers[address] = toSignedBigInt(balance);
+    }
+    result = {
+      schema: TransfersStepSummarySchema,
+      hash: context.head,
+      stepSize: -1,
+      transfers,
+      account
+    };
+  } else {
+    const step = StepSizes4.indexOf(frameSize);
+    assertEx5(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes4.join(", ")}`);
+    const [summaryResult] = await context.summaryRepository.get([
+      frameHeadHash
+    ]);
+    if (isAnyPayload2(summaryResult)) {
+      result = summaryResult;
+    } else {
+      const subRanges = deepCalculateFramesFromRange(range, step - 1);
+      const promises = subRanges.map((subRange) => transfersStepSummaryFromRange(context, subRange));
+      const subResults = await Promise.all(promises);
+      const bigIntBalances = {};
+      for (const subResult of subResults) {
+        for (const [address, transfer] of Object.entries(subResult.transfers)) {
+          bigIntBalances[address] = (bigIntBalances[address] ?? 0n) + parseSignedBigInt(transfer);
+        }
+      }
+      const transfers = {};
+      for (const [address, transfer] of Object.entries(bigIntBalances)) {
+        transfers[address] = toSignedBigInt(transfer);
+      }
+      result = {
+        schema: TransfersStepSummarySchema,
+        hash: frameHeadHash,
+        stepSize: frameSize,
+        transfers,
+        account
+      };
+      await context.summaryRepository.insert([
+        result
+      ]);
+    }
+  }
+  const finalResult = await PayloadBuilder2.addStorageMeta(result);
+  return finalResult;
+}
+__name(transfersStepSummaryFromRange, "transfersStepSummaryFromRange");
+
+// src/block/primitives/transfers/transfersSummary.ts
+import { asAddress as asAddress2 } from "@xylabs/hex";
+import { spanRootAsync as spanRootAsync2 } from "@xylabs/telemetry";
+import { isDefined as isDefined2 } from "@xylabs/typeof";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3 } from "@xyo-network/xl1-protocol";
+async function transfersSummary(context) {
+  return await spanRootAsync2("transferSummary", async () => {
+    const headResult = await context.chainArchivist.get([
+      context.head
+    ]);
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta3(headResult.at(0), () => `Head block not found for hash: ${context.head}`, {
+      required: true
+    });
+    const rangeStart = isDefined2(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0;
+    const ranges = deepCalculateFramesFromRange([
+      rangeStart,
+      headBoundWitness.block
+    ]);
+    const summaries = await Promise.all(ranges.map((range) => transfersStepSummaryFromRange(context, range)));
+    const transfers = {};
+    for (let summary of summaries) {
+      for (const [address, transfer] of Object.entries(summary.transfers)) {
+        const validAddress = asAddress2(address, () => `Invalid address: ${address}`);
+        transfers[validAddress] = (transfers[validAddress] ?? 0n) + parseSignedBigInt(transfer);
+      }
+    }
+    return transfers;
+  });
+}
+__name(transfersSummary, "transfersSummary");
 
 // src/config/Config.ts
 import * as z11 from "zod";
@@ -493,9 +651,20 @@ var LogConfigZod = z6.object({
 });
 
 // src/config/Producer.ts
+import { AddressZod, asAddress as asAddress3 } from "@xylabs/hex";
 import { globalRegistry as globalRegistry6 } from "zod";
 import * as z7 from "zod";
 var ProducerConfigZod = z7.object({
+  allowlist: z7.preprocess((val) => {
+    if (typeof val === "string") {
+      return val.split(",").map((s) => asAddress3(s.trim()));
+    }
+    return val;
+  }, z7.array(AddressZod).optional().register(globalRegistry6, {
+    description: "List of allowed producer addresses, if undefined anyone can participate",
+    title: "allowlist",
+    type: "array"
+  })),
   disableIntentRedeclaration: z7.boolean().optional().register(globalRegistry6, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
     title: "producer.disableIntentRedeclaration",
@@ -507,6 +676,11 @@ var ProducerConfigZod = z7.object({
     title: "producer.healthCheckPort",
     type: "number"
   }),
+  heartbeatInterval: z7.coerce.number().default(36e5).register(globalRegistry6, {
+    description: "The number of milliseconds between heartbeats if no blocks are produced",
+    title: "producer.heartbeatInterval",
+    type: "number"
+  }),
   // TODO: BigInt schema
   minStake: z7.coerce.number().default(1).register(globalRegistry6, {
     description: "Minimum stake required to be a Producer",
@@ -534,12 +708,12 @@ var ProducerConfigZod = z7.object({
 });
 
 // src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined2, isUndefined } from "@xylabs/typeof";
+import { isDefined as isDefined3, isUndefined } from "@xylabs/typeof";
 import { globalRegistry as globalRegistry7 } from "zod";
 import * as z8 from "zod";
 var hasMongoConfig = /* @__PURE__ */ __name((config) => {
   if (isUndefined(config)) return false;
-  return isDefined2(config.connectionString) && isDefined2(config.database) && isDefined2(config.domain) && isDefined2(config.password) && isDefined2(config.username);
+  return isDefined3(config.connectionString) && isDefined3(config.database) && isDefined3(config.domain) && isDefined3(config.password) && isDefined3(config.username);
 }, "hasMongoConfig");
 var MongoConfigZod = z8.object({
   // TODO: Create from other arguments
@@ -651,11 +825,232 @@ function isUsageMeta(v) {
 }
 __name(isUsageMeta, "isUsageMeta");
 
+// src/steps/primitives/addressStakeWeight.ts
+import { toAddress as toAddress2 } from "@xylabs/hex";
+import { XYO_NETWORK_STAKING_ADDRESS } from "@xyo-network/xl1-protocol";
+async function addressStakeWeight(stakeContract, staked, by, startEthBlock, endEthBlock) {
+  const stakeAddedFilter = stakeContract.filters.StakeAdded(`0x${XYO_NETWORK_STAKING_ADDRESS}`, by);
+  const stakeAddedEvents = await stakeContract.queryFilter(stakeAddedFilter, startEthBlock, endEthBlock);
+  const stakeRemovedFilter = stakeContract.filters.StakeRemoved(`0x${XYO_NETWORK_STAKING_ADDRESS}`, by);
+  const stakeRemovedEvents = await stakeContract.queryFilter(stakeRemovedFilter, startEthBlock, endEthBlock);
+  const accountStakes = [];
+  const accountStakeCount = await stakeContract.getStakeCountForAddress(`0x${by}`, {
+    blockTag: startEthBlock - 1
+  });
+  for (let i = 0; i < accountStakeCount; i++) {
+    try {
+      const stake = await stakeContract.getStake(`0x${by}`, i, {
+        blockTag: startEthBlock - 1
+      });
+      accountStakes.push(stake);
+    } catch {
+      break;
+    }
+  }
+  const ethStakedAddress = toAddress2(staked, {
+    prefix: false
+  }).toLowerCase();
+  const networkStakes = accountStakes.filter((s) => s.staked.toLowerCase() === ethStakedAddress);
+  let totalStake = 0n;
+  for (const stake of networkStakes) {
+    totalStake += stake.amount;
+  }
+  let totalWeight = 0n;
+  let addIndex = 0;
+  let removeIndex = 0;
+  for (let i = startEthBlock; i <= endEthBlock; i++) {
+    while (addIndex < stakeAddedEvents.length && stakeAddedEvents[addIndex]?.blockNumber === i) {
+      totalStake += stakeAddedEvents[addIndex].args.amount;
+      addIndex++;
+    }
+    while (removeIndex < stakeRemovedEvents.length && stakeRemovedEvents[removeIndex]?.blockNumber === i) {
+      totalStake -= stakeRemovedEvents[removeIndex].args.amount;
+      removeIndex++;
+    }
+    totalWeight += totalStake;
+  }
+  return totalWeight;
+}
+__name(addressStakeWeight, "addressStakeWeight");
+
+// src/steps/primitives/claimedRewards.ts
+function claimedRewards(_address) {
+  return 0n;
+}
+__name(claimedRewards, "claimedRewards");
+
+// src/steps/primitives/networkStakeStepAddressReward.ts
+function networkStakeStepAddressReward(address, step, block) {
+  return {
+    [address]: 0n
+  };
+}
+__name(networkStakeStepAddressReward, "networkStakeStepAddressReward");
+
+// src/steps/primitives/networkStakeStepPoolRewards.ts
+function networkStakeStepPoolRewards(step, block) {
+  return {};
+}
+__name(networkStakeStepPoolRewards, "networkStakeStepPoolRewards");
+
+// src/steps/primitives/networkStakeStepPoolRewardShares.ts
+function networkStakeStepPoolRewardShares(step, block) {
+  return {};
+}
+__name(networkStakeStepPoolRewardShares, "networkStakeStepPoolRewardShares");
+
+// src/steps/primitives/networkStakeStepRewardAddressHistory.ts
+function networkStakeStepRewardAddressHistory(address) {
+  return {
+    [address]: 0n
+  };
+}
+__name(networkStakeStepRewardAddressHistory, "networkStakeStepRewardAddressHistory");
+
+// src/steps/primitives/networkStakeStepRewardAddressShare.ts
+function networkStakeStepRewardAddressShare(address, step, block) {
+  throw new Error("Method not implemented.");
+}
+__name(networkStakeStepRewardAddressShare, "networkStakeStepRewardAddressShare");
+
+// src/steps/primitives/networkStakeStepRewardForStep.ts
+function networkStakeStepRewardForStep(step) {
+  return 0n;
+}
+__name(networkStakeStepRewardForStep, "networkStakeStepRewardForStep");
+
+// src/steps/primitives/networkStakeStepRewardPositionWeight.ts
+function networkStakeStepRewardPositionWeight(position, step) {
+  throw new Error("Method not implemented.");
+}
+__name(networkStakeStepRewardPositionWeight, "networkStakeStepRewardPositionWeight");
+
+// src/steps/primitives/networkStakeStepRewardPotentialPositionLoss.ts
+function networkStakeStepRewardPotentialPositionLoss(position, step) {
+  throw new Error("Method not implemented.");
+}
+__name(networkStakeStepRewardPotentialPositionLoss, "networkStakeStepRewardPotentialPositionLoss");
+
+// src/steps/primitives/networkStakeStepRewardRandomizer.ts
+function networkStakeStepRewardRandomizer(step, block) {
+  throw new Error("Method not implemented.");
+}
+__name(networkStakeStepRewardRandomizer, "networkStakeStepRewardRandomizer");
+
+// src/steps/primitives/networkStakeStepRewardWeightForAddress.ts
+function networkStakeStepRewardWeightForAddress(address, step) {
+  throw new Error("Method not implemented.");
+}
+__name(networkStakeStepRewardWeightForAddress, "networkStakeStepRewardWeightForAddress");
+
+// src/steps/primitives/stakersAsOfBlock.ts
+import { toAddress as toAddress4 } from "@xylabs/hex";
+
+// src/steps/primitives/startingStakes.ts
+import { toAddress as toAddress3 } from "@xylabs/hex";
+import { XYO_NETWORK_STAKING_ADDRESS as XYO_NETWORK_STAKING_ADDRESS2 } from "@xyo-network/xl1-protocol";
+async function startingStakes(stakeContract, staked, ethBlock) {
+  const stakeAddedFilter = stakeContract.filters.StakeAdded(toAddress3(XYO_NETWORK_STAKING_ADDRESS2, {
+    prefix: true
+  }));
+  const stakeAddedEvents = await stakeContract.queryFilter(stakeAddedFilter, 0, ethBlock);
+  const stakeRemovedFilter = stakeContract.filters.StakeRemoved(`0x${XYO_NETWORK_STAKING_ADDRESS2}`);
+  const stakeRemovedEvents = await stakeContract.queryFilter(stakeRemovedFilter, 0, ethBlock);
+  const stakes = {};
+  for (const event of stakeAddedEvents) {
+    const by = toAddress3(event.args.by.toLowerCase(), {
+      prefix: false
+    });
+    stakes[by] = (stakes[by] ?? 0n) + event.args.amount;
+  }
+  for (const event of stakeRemovedEvents) {
+    const by = toAddress3(event.args.by.toLowerCase(), {
+      prefix: false
+    });
+    stakes[by] = (stakes[by] ?? 0n) - event.args.amount;
+  }
+  const filteredStakes = {};
+  for (const [address, amount] of Object.entries(stakes)) {
+    if (amount > 0n) {
+      filteredStakes[address] = amount;
+    }
+  }
+  return filteredStakes;
+}
+__name(startingStakes, "startingStakes");
+
+// src/steps/primitives/stakersAsOfBlock.ts
+async function stakersAsOfBlock(stakeContract, staked, ethBlock) {
+  const stakes = await startingStakes(stakeContract, staked, ethBlock);
+  let results = [];
+  for (const [address, amount] of Object.entries(stakes)) {
+    if (amount > 0n) {
+      results.push(toAddress4(address, {
+        prefix: false
+      }));
+    }
+  }
+  return results;
+}
+__name(stakersAsOfBlock, "stakersAsOfBlock");
+
+// src/steps/primitives/totalStakeWeight.ts
+import { toAddress as toAddress5 } from "@xylabs/hex";
+import { XYO_NETWORK_STAKING_ADDRESS as XYO_NETWORK_STAKING_ADDRESS3 } from "@xyo-network/xl1-protocol";
+async function totalStakeWeight(stakeContract, staked, startEthBlock, endEthBlock) {
+  const stakeAddedFilter = stakeContract.filters.StakeAdded(`0x${XYO_NETWORK_STAKING_ADDRESS3}`);
+  const stakeAddedEvents = await stakeContract.queryFilter(stakeAddedFilter, startEthBlock, endEthBlock);
+  const stakeRemovedFilter = stakeContract.filters.StakeRemoved(`0x${XYO_NETWORK_STAKING_ADDRESS3}`);
+  const stakeRemovedEvents = await stakeContract.queryFilter(stakeRemovedFilter, startEthBlock, endEthBlock);
+  const stakes = await startingStakes(stakeContract, staked, startEthBlock);
+  let totalWeight = 0n;
+  let addIndex = 0;
+  let removeIndex = 0;
+  for (let i = startEthBlock; i <= endEthBlock; i++) {
+    while (addIndex < stakeAddedEvents.length && stakeAddedEvents[addIndex]?.blockNumber === i) {
+      const by = toAddress5(stakeAddedEvents[addIndex].args.by.toLowerCase(), {
+        prefix: false
+      });
+      stakes[by] = (stakes[by] ?? 0n) + stakeAddedEvents[addIndex].args.amount;
+      addIndex++;
+    }
+    while (removeIndex < stakeRemovedEvents.length && stakeRemovedEvents[removeIndex]?.blockNumber === i) {
+      const by = toAddress5(stakeAddedEvents[addIndex].args.by.toLowerCase(), {
+        prefix: false
+      });
+      stakes[by] = (stakes[by] ?? 0n) - stakeRemovedEvents[addIndex].args.amount;
+      removeIndex++;
+    }
+    totalWeight += Object.values(stakes).reduce((a, b) => a + b, 0n);
+  }
+  return totalWeight;
+}
+__name(totalStakeWeight, "totalStakeWeight");
+
+// src/steps/primitives/unclaimedRewards.ts
+function unclaimedRewards(address) {
+  throw new Error("Method not implemented.");
+}
+__name(unclaimedRewards, "unclaimedRewards");
+
+// src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
+import { assertEx as assertEx6 } from "@xylabs/assert";
+import { asTimePayload, TimeSchema } from "@xyo-network/xl1-protocol";
+async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
+  const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
+  const hydratedBlock = await hydrateBlock(context.chainArchivist, blockHash);
+  const timePayload = asTimePayload(hydratedBlock[1].find((p) => p.schema === TimeSchema), {
+    required: true
+  });
+  return assertEx6(timePayload.ethereum, () => "No ethereum timestamp found on block");
+}
+__name(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
+
 // src/transaction/buildTransaction.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
+import { assertEx as assertEx7 } from "@xylabs/assert";
 import { toHex as toHex2 } from "@xylabs/hex";
 import { BoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
 import { defaultTransactionFees } from "@xyo-network/xl1-protocol";
 async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer, nbf, exp, from, fees = defaultTransactionFees) {
   if (from === void 0 && Array.isArray(signer)) {
@@ -672,14 +1067,14 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
     nbf,
     exp
   };
-  const elevatedHashes = await PayloadBuilder2.hashes(onChainPayloads);
+  const elevatedHashes = await PayloadBuilder3.hashes(onChainPayloads);
   const script = [];
   for (const elevatedHash of elevatedHashes) {
     script.push(`elevate|${elevatedHash}`);
   }
   const fields = {
     ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx3(signer.at(0)?.address) : signer.address)
+    from: from ?? (Array.isArray(signer) ? assertEx7(signer.at(0)?.address) : signer.address)
   };
   if (script.length > 0) {
     fields.script = script;
@@ -693,8 +1088,8 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
     signer
   ]).build();
   return [
-    await PayloadBuilder2.addStorageMeta(tx),
-    await PayloadBuilder2.addStorageMeta(txPayloads)
+    await PayloadBuilder3.addStorageMeta(tx),
+    await PayloadBuilder3.addStorageMeta(txPayloads)
   ];
 }
 __name(buildTransaction, "buildTransaction");
@@ -702,7 +1097,7 @@ __name(buildTransaction, "buildTransaction");
 // src/transaction/buildUnsignedTransaction.ts
 import { toHex as toHex3 } from "@xylabs/hex";
 import { BoundWitnessBuilder as BoundWitnessBuilder2 } from "@xyo-network/boundwitness-builder";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 import { defaultTransactionFees as defaultTransactionFees2 } from "@xyo-network/xl1-protocol";
 async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads, nbf, exp, from, fees = defaultTransactionFees2) {
   const txBoundWitnessFields = {
@@ -716,7 +1111,7 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
     nbf,
     exp
   };
-  const elevatedHashes = await PayloadBuilder3.hashes(onChainPayloads);
+  const elevatedHashes = await PayloadBuilder4.hashes(onChainPayloads);
   const script = [];
   for (const elevatedHash of elevatedHashes) {
     script.push(`elevate|${elevatedHash}`);
@@ -735,26 +1130,26 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
     ...offChainPayloads
   ]).build();
   return [
-    await PayloadBuilder3.addStorageMeta(tx),
-    await PayloadBuilder3.addStorageMeta(txPayloads)
+    await PayloadBuilder4.addStorageMeta(tx),
+    await PayloadBuilder4.addStorageMeta(txPayloads)
   ];
 }
 __name(buildUnsignedTransaction, "buildUnsignedTransaction");
 
 // src/transaction/confirmSubmittedTransaction.ts
 import { delay } from "@xylabs/delay";
-import { isDefined as isDefined3 } from "@xylabs/typeof";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { isDefined as isDefined4 } from "@xylabs/typeof";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
 var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transaction, options) => {
   const { attempts: maxAttempts = DEFAULT_CONFIRMATION_ATTEMPTS, delay: attemptDelay = DEFAULT_DELAY_BETWEEN_ATTEMPTS } = options || {};
-  const txBWHash = await PayloadBuilder4.hash(transaction);
+  const txBWHash = await PayloadBuilder5.hash(transaction);
   options?.logger?.log("\u{1F680} confirming transaction:", txBWHash, "\n");
   let attempts = 0;
   while (true) {
     const tx = await viewer.transactionByHash(txBWHash) ?? void 0;
-    if (isDefined3(tx)) {
+    if (isDefined4(tx)) {
       options?.logger?.log("\u2705 Transaction confirmed:", txBWHash, "\n");
       return tx;
     } else {
@@ -771,7 +1166,7 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transact
 }, "confirmSubmittedTransaction");
 
 // src/transaction/hydrateTransaction.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
+import { assertEx as assertEx8 } from "@xylabs/assert";
 import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from "@xyo-network/archivist-model";
 import { isAllowedBlockPayload, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var tryHydrateTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
@@ -814,15 +1209,15 @@ var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async (archivist, has
   return void 0;
 }, "tryHydrateElevatedTransaction");
 var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
-  return assertEx4(await tryHydrateElevatedTransaction(archivist, hash), () => "Hydration failed");
+  return assertEx8(await tryHydrateElevatedTransaction(archivist, hash), () => "Hydration failed");
 }, "hydrateElevatedTransaction");
 
 // src/transaction/primitives/transactionBlockByteCount.ts
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
 function transactionBlockByteCount([transaction, payloads]) {
-  const cleanTransaction = PayloadBuilder5.omitStorageMeta(transaction);
+  const cleanTransaction = PayloadBuilder6.omitStorageMeta(transaction);
   const transactionBytes = JSON.stringify(cleanTransaction).length;
-  const cleanPayloads = PayloadBuilder5.omitStorageMeta(payloads);
+  const cleanPayloads = PayloadBuilder6.omitStorageMeta(payloads);
   return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
 }
 __name(transactionBlockByteCount, "transactionBlockByteCount");
@@ -880,7 +1275,7 @@ __name(transactionRequiredGas, "transactionRequiredGas");
 
 // src/transaction/script.ts
 import { filterAs as filterAs2 } from "@xylabs/array";
-import { assertEx as assertEx5 } from "@xylabs/assert";
+import { assertEx as assertEx9 } from "@xylabs/assert";
 import { asHash as asHash3 } from "@xylabs/hex";
 import { isAllowedBlockPayloadWithHashStorageMeta } from "@xyo-network/xl1-protocol";
 var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
@@ -890,7 +1285,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));
-  assertEx5(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx9(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashesFromScript");
 var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
@@ -904,17 +1299,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);
-  assertEx5(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx9(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashes");
 
 // src/transaction/signTransaction.ts
 import { toArrayBuffer } from "@xylabs/arraybuffer";
-import { assertEx as assertEx6 } from "@xylabs/assert";
+import { assertEx as assertEx10 } from "@xylabs/assert";
 import { hexFromArrayBuffer } from "@xylabs/hex";
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 async function signTransaction(tx, account) {
-  assertEx6(tx.from === account.address, () => "Signer address does not match transaction from address");
+  assertEx10(tx.from === account.address, () => "Signer address does not match transaction from address");
   const signedTx = structuredClone(tx);
   signedTx.addresses = [
     account.address
@@ -922,7 +1317,7 @@ async function signTransaction(tx, account) {
   signedTx.previous_hashes = [
     account.previousHash ?? null
   ];
-  const hash = await PayloadBuilder6.dataHash(signedTx);
+  const hash = await PayloadBuilder7.dataHash(signedTx);
   const hashBytes = toArrayBuffer(hash);
   const [signature] = await account.sign(hashBytes);
   signedTx.$signatures = [
@@ -972,18 +1367,24 @@ export {
   MnemonicStringZod,
   StepSummarySchema,
   TODO,
+  TransfersStepSummarySchema,
   UsageMetaSchema,
   WALLET_COMPLIANCE,
   Xl1CommonConfigSchema,
+  addressStakeWeight,
   allHashesPresent,
   asBalancesStepSummary,
   asBalancesStepSummaryWithStorageMeta,
-  balanceStepSummaryFromRange,
-  balanceSummary,
+  asTransfersStepSummary,
+  asTransfersStepSummaryWithStorageMeta,
+  balancesStepSummaryFromRange,
+  balancesSummary,
+  blockFromBlockNumber,
   blockPayloadsFromHydratedBlock,
   buildTransaction,
   buildUnsignedTransaction,
   calculateFramesFromRange,
+  claimedRewards,
   confirmSubmittedTransaction,
   crackOperation,
   crackOperations,
@@ -1007,22 +1408,42 @@ export {
   isLocalhost,
   isNegativeBigInt,
   isPositiveBigInt,
+  isTransfersStepSummary,
+  isTransfersStepSummaryWithStorageMeta,
   isUsageMeta,
   netBalancesForPayloads,
+  netTransfersForPayloads,
+  networkStakeStepAddressReward,
+  networkStakeStepPoolRewardShares,
+  networkStakeStepPoolRewards,
+  networkStakeStepRewardAddressHistory,
+  networkStakeStepRewardAddressShare,
+  networkStakeStepRewardForStep,
+  networkStakeStepRewardPositionWeight,
+  networkStakeStepRewardPotentialPositionLoss,
+  networkStakeStepRewardRandomizer,
+  networkStakeStepRewardWeightForAddress,
   parseSignedBigInt,
   signTransaction,
+  stakersAsOfBlock,
+  startingStakes,
   toPositiveBigInt,
   toSignedBigInt,
+  totalStakeWeight,
   transactionBlockByteCount,
   transactionBytesRequiredGas,
   transactionElevatedPayloadHashes,
   transactionElevatedPayloads,
   transactionRequiredGas,
   transactionsFromHydratedBlock,
+  transfersStepSummaryFromRange,
+  transfersSummary,
   tryExtractElevatedHashes,
   tryExtractElevatedHashesFromScript,
   tryHydrateBlock,
   tryHydrateElevatedTransaction,
-  tryHydrateTransaction
+  tryHydrateTransaction,
+  unclaimedRewards,
+  xl1BlockNumberToEthBlockNumber
 };
 //# sourceMappingURL=index.mjs.map