@xyo-network/xl1-protocol-sdk 1.16.8 → 1.16.10

package/dist/neutral/block/primitives/frames/calculateFramesFromRange.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateFramesFromRange.d.ts","sourceRoot":"","sources":["../../../../../src/block/primitives/frames/calculateFramesFromRange.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAG9D,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG;IAE5E,aAAa,EAAE;IAEf,aAAa,EAAE;CAAC,CAoBjB"}
+{"version":3,"file":"calculateFramesFromRange.d.ts","sourceRoot":"","sources":["../../../../../src/block/primitives/frames/calculateFramesFromRange.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAG9D,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG;IAE5E,aAAa,EAAE;IAEf,aAAa,EAAE;CAAC,CAqBjB"}

package/dist/neutral/block/primitives/transfers/transfersSummary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transfersSummary.d.ts","sourceRoot":"","sources":["../../../../../src/block/primitives/transfers/transfersSummary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAQhD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AAM1E,wBAAsB,gBAAgB,CACpC,eAAe,EAAE,2BAA2B,GAC3C,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAqBrE;AAED,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,UAEzE"}
+{"version":3,"file":"transfersSummary.d.ts","sourceRoot":"","sources":["../../../../../src/block/primitives/transfers/transfersSummary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAQhD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AAM1E,wBAAsB,gBAAgB,CACpC,eAAe,EAAE,2BAA2B,GAC3C,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAwBrE;AAED,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,UAEzE"}

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

@@ -45,11 +45,7 @@ export declare const ConfigZod: z.ZodObject<{
         port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     }, z.core.$strip>>;
     producer: z.ZodDefault<z.ZodObject<{
-        allowlist: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-            readonly __address: true;
-        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-            readonly __address: true;
-        }>, unknown>>>>>;
+        allowlist: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>>;
         disableIntentRedeclaration: z.ZodOptional<z.ZodBoolean>;
         healthCheckPort: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
         heartbeatInterval: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
@@ -80,16 +76,8 @@ export declare const ConfigZod: z.ZodObject<{
         }, 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/hex").Hex, {
-            readonly __address: true;
-        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-            readonly __address: true;
-        }>, unknown>>>>>;
-        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-            readonly __address: true;
-        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-            readonly __address: true;
-        }>, unknown>>>>>;
+        allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>>;
+        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>>;
     }, z.core.$strip>>;
     logLevel: z.ZodDefault<z.ZodEnum<{
         info: "info";

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;AAexB,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAAmF,CAAA;AAErH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAapB,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;AAexB,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAAmF,CAAA;AAErH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAapB,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/Producer.d.ts

@@ -1,10 +1,6 @@
 import * as z from 'zod';
 export declare const ProducerConfigZod: z.ZodObject<{
-    allowlist: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, unknown>>>>>;
+    allowlist: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>>;
     disableIntentRedeclaration: z.ZodOptional<z.ZodBoolean>;
     healthCheckPort: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     heartbeatInterval: z.ZodDefault<z.ZodCoercedNumber<unknown>>;

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

@@ -1 +1 @@
-{"version":3,"file":"Producer.d.ts","sourceRoot":"","sources":["../../../src/config/Producer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;iBAoD5B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"version":3,"file":"Producer.d.ts","sourceRoot":"","sources":["../../../src/config/Producer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,iBAAiB;;;;;;;;;iBAoD5B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

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

@@ -1,15 +1,7 @@
 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/hex").Hex, {
-        readonly __address: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, unknown>>>>>;
-    allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, unknown>>>>>;
+    allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>>;
+    allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>>;
 }, z.core.$strip>;
 export type ValidationConfig = z.infer<typeof ValidationConfigZod>;
 //# sourceMappingURL=Validation.d.ts.map

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

@@ -1 +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"}
+{"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.mjs

@@ -227,13 +227,6 @@ async function withContextCacheResponse(context, name, key, func, options) {
 }
 __name(withContextCacheResponse, "withContextCacheResponse");
 
-// src/model/StakeEvents.ts
-var StakeEventNames = [
-  "StakeAdded",
-  "StakeRemoved",
-  "StakeWithdrawn"
-];
-
 // src/block/primitives/blockFromBlockNumber.ts
 async function blockFromBlockNumber(context, blockNumber) {
   const cacheKey = `${blockNumber}`;
@@ -244,7 +237,7 @@ async function blockFromBlockNumber(context, blockNumber) {
       required: true
     });
     if (currentBlock.block < blockNumber) {
-      throw new Error(`Error: Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
+      throw new Error(`Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
     }
     while (currentBlock.block > blockNumber) {
       let jumpHash = currentBlock.previous;
@@ -289,12 +282,18 @@ function calculateFramesFromRange(range, step) {
   for (let i = start; i <= range[1]; i += size) {
     if (i + size - 1 <= range[1]) {
       fitted.push([
-        asXL1BlockNumber(i, true),
-        asXL1BlockNumber(Math.min(i + size - 1, range[1]), true)
+        asXL1BlockNumber(i, {
+          name: "calculateFramesFromRange A"
+        }),
+        asXL1BlockNumber(Math.min(i + size - 1, range[1]), {
+          name: "calculateFramesFromRange B"
+        })
       ]);
     } else {
       remaining.push([
-        asXL1BlockNumber(i, true),
+        asXL1BlockNumber(i, {
+          name: "calculateFramesFromRange C"
+        }),
         range[1]
       ]);
     }
@@ -502,7 +501,9 @@ async function transfersSummary(transferContext) {
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange([
       rangeStart,
       headBoundWitness.block
-    ], true));
+    ], {
+      name: "transfersSummary"
+    }));
     const summaries = await Promise.all(ranges.map((range) => transfersStepSummaryFromRange(transferContext, range)));
     const transfers = {};
     for (let summary of summaries) {
@@ -1226,7 +1227,9 @@ function stepBlockRange({ block, step }) {
   return asXL1BlockRange2([
     start,
     start + stepSize2 - 1
-  ], true);
+  ], {
+    name: "stepBlockRange"
+  });
 }
 __name(stepBlockRange, "stepBlockRange");
 
@@ -1245,7 +1248,7 @@ function stepTransferIndex(block, step) {
       rewardTransferCount++;
     }
   }
-  assertEx5(rewardTransferIndex >= 0, () => `Error: Could not find step size for step ${step} at block ${block}`);
+  assertEx5(rewardTransferIndex >= 0, () => `Could not find step size for step ${step} at block ${block}`);
   return [
     rewardTransferIndex,
     rewardTransferCount
@@ -1331,7 +1334,9 @@ async function balancesSummary(context) {
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange3([
       rangeStart,
       headBoundWitness.block
-    ], true));
+    ], {
+      name: "balancesSummary"
+    }));
     const summaries = await Promise.all(ranges.map((range) => balancesStepSummaryFromRange(context, range)));
     const balances = {};
     for (let summary of summaries) {
@@ -1390,6 +1395,119 @@ var asChainIndexingServiceState = AsObjectFactory6.create(isChainIndexingService
 var isChainIndexingServiceStateWithStorageMeta = /* @__PURE__ */ __name((value) => isChainIndexingServiceState(value) && isStorageMeta3(value), "isChainIndexingServiceStateWithStorageMeta");
 var asChainIndexingServiceStateWithStorageMeta = AsObjectFactory6.create(isChainIndexingServiceStateWithStorageMeta);
 
+// src/simple/accountBalance/SimpleAccountBalanceViewer.ts
+import { assertEx as assertEx7 } from "@xylabs/assert";
+import { exists } from "@xylabs/exists";
+import { spanRootAsync as spanRootAsync3 } from "@xylabs/telemetry";
+import { isDefined as isDefined8 } from "@xylabs/typeof";
+import { asRange, asXL1BlockNumber as asXL1BlockNumber4, asXL1BlockRange as asXL1BlockRange4, AttoXL1, StepSizes as StepSizes8, TransferSchema } from "@xyo-network/xl1-protocol";
+var SimpleAccountBalanceViewer = class {
+  static {
+    __name(this, "SimpleAccountBalanceViewer");
+  }
+  blockViewer;
+  context;
+  transferContext;
+  constructor(context, transferContext, blockViewer) {
+    this.context = context;
+    this.transferContext = transferContext;
+    this.blockViewer = blockViewer;
+  }
+  async accountBalance(address, headOrRange) {
+    const balances = await this.accountBalances([
+      address
+    ], headOrRange);
+    return balances[address] ?? AttoXL1(0n);
+  }
+  async accountBalanceHistory(address, headOrRange) {
+    const range = asRange(headOrRange);
+    const startingRange = asXL1BlockRange4(range ?? [
+      0,
+      await this.blockViewer.currentBlockNumber()
+    ], true);
+    const blockNumbers = await this.distillTransferHistory(address, startingRange);
+    const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)))).filter(exists);
+    const result = [];
+    for (const block of blocks) {
+      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : void 0).filter(exists);
+      const transfers = transferIndexes.map((index) => {
+        const hash = block[0].payload_hashes[index];
+        return assertEx7(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
+      }).filter(exists).filter((t) => t.from === address || isDefined8(t.transfers[address]));
+      if (transfers.length === 0) {
+        continue;
+      }
+      const pairs = transfers.map((transfer) => {
+        return [
+          block[0],
+          transfer
+        ];
+      });
+      result.push(...pairs.map(([block2, transfer]) => [
+        block2,
+        null,
+        transfer
+      ]));
+    }
+    return result;
+  }
+  async accountBalances(address, _headOrRange) {
+    return await spanRootAsync3("balances", async () => {
+      const summary = await balancesSummary(this.context);
+      const result = {};
+      for (const addr of address) {
+        const summaryBalance = summary[addr] ?? 0n;
+        result[addr] = AttoXL1(summaryBalance < 0n ? 0n : summaryBalance);
+      }
+      return result;
+    });
+  }
+  accountBalancesHistories(_addresses, _rangeOrHash) {
+    throw new Error("Method not implemented.");
+  }
+  async distillTransferHistory(address, range, max = 50) {
+    if (range[1] - range[0] <= StepSizes8[0] || max <= 1) {
+      return Array.from({
+        length: range[1] - range[0] + 1
+      }, (_, i) => range[1] - i).slice(0, max).map((n) => asXL1BlockNumber4(n, true));
+    }
+    const frames = deepCalculateFramesFromRange(asXL1BlockRange4(range, true));
+    const transferSummaryPairs = await Promise.all(frames.map(async (frame) => {
+      return [
+        frame,
+        await transfersStepSummaryFromRange(this.transferContext, frame)
+      ];
+    }));
+    const filteredTransferSummaryPairs = transferSummaryPairs.filter(([_, summary]) => Object.keys(summary.transfers).includes(address));
+    const sortedTransferSummaryPairs = filteredTransferSummaryPairs.toSorted((a, b) => {
+      return b[0][1] - a[0][1];
+    });
+    const resultBlockNumbers = /* @__PURE__ */ new Set();
+    for (const [frame] of sortedTransferSummaryPairs) {
+      if (frame[1] - frame[0] + 1 > StepSizes8[0]) {
+        const values = await this.distillTransferHistory(address, asXL1BlockRange4([
+          frame[0],
+          frame[1] - 1
+        ], true), max - resultBlockNumbers.size);
+        for (const value of values) {
+          resultBlockNumbers.add(value);
+        }
+        resultBlockNumbers.add(frame[1]);
+      } else {
+        for (let i = frame[0]; i <= frame[1]; i++) {
+          resultBlockNumbers.add(i);
+        }
+      }
+      if (resultBlockNumbers.size >= max) {
+        break;
+      }
+    }
+    return [
+      ...resultBlockNumbers
+    ].toSorted((a, b) => b - a).slice(0, max);
+  }
+};
+
 // src/simple/client/SimpleXyoClient.ts
 var SimpleXyoClient = class {
   static {
@@ -1508,14 +1626,14 @@ var SimpleXyoGateway = class {
 };
 
 // src/simple/gateway/SimpleXyoGatewayRunner.ts
-import { assertEx as assertEx11 } from "@xylabs/assert";
+import { assertEx as assertEx12 } from "@xylabs/assert";
 import { BigIntToJsonZod } from "@xylabs/hex";
-import { isDefined as isDefined9 } from "@xylabs/typeof";
+import { isDefined as isDefined10 } from "@xylabs/typeof";
 import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
-import { TransferSchema } from "@xyo-network/xl1-protocol";
+import { TransferSchema as TransferSchema2 } from "@xyo-network/xl1-protocol";
 
 // 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 PayloadBuilder5 } from "@xyo-network/payload-builder";
@@ -1542,7 +1660,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;
@@ -1606,7 +1724,7 @@ __name(buildUnsignedTransaction, "buildUnsignedTransaction");
 
 // src/transaction/confirmSubmittedTransaction.ts
 import { delay } from "@xylabs/delay";
-import { isDefined as isDefined8 } from "@xylabs/typeof";
+import { isDefined as isDefined9 } from "@xylabs/typeof";
 import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
@@ -1617,7 +1735,7 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transact
   let attempts = 0;
   while (true) {
     const tx = await viewer.transactionByHash(txBWHash) ?? void 0;
-    if (isDefined8(tx)) {
+    if (isDefined9(tx)) {
       options?.logger?.log("\u2705 Transaction confirmed:", txBWHash, "\n");
       return tx;
     } else {
@@ -1634,7 +1752,7 @@ 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 as isAllowedBlockPayload2, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var tryHydrateTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
@@ -1693,7 +1811,7 @@ var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async ({ chainMap },
   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
@@ -1740,26 +1858,26 @@ function transactionElevatedPayloads([transaction, payloads]) {
 __name(transactionElevatedPayloads, "transactionElevatedPayloads");
 
 // src/transaction/primitives/transactionRequiredGas.ts
-import { AttoXL1, TransactionGasCosts } from "@xyo-network/xl1-protocol";
+import { AttoXL1 as AttoXL12, TransactionGasCosts } from "@xyo-network/xl1-protocol";
 function transactionBytesRequiredGas([transaction, payloads]) {
   const transactionBlockBytes = transactionBlockByteCount([
     transaction,
     payloads
   ]);
-  return AttoXL1(TransactionGasCosts.characterStorage * BigInt(transactionBlockBytes));
+  return AttoXL12(TransactionGasCosts.characterStorage * BigInt(transactionBlockBytes));
 }
 __name(transactionBytesRequiredGas, "transactionBytesRequiredGas");
 function transactionRequiredGas(hydratedTransaction) {
   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(elevatedPayloads2.length));
+  return AttoXL12(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 asHash4 } from "@xylabs/hex";
 import { isAllowedBlockPayloadWithHashMeta } from "@xyo-network/xl1-protocol";
 var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
@@ -1769,7 +1887,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) => asHash4(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) => {
@@ -1783,17 +1901,17 @@ var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
   const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
-  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 PayloadBuilder9 } 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
@@ -1838,24 +1956,24 @@ var SimpleXyoGatewayRunner = class {
     return this._dataLakes.length - 1;
   }
   async addPayloadsToChain(onChain, offChain, options) {
-    const viewer = assertEx11(this.connectionInstance.viewer, () => "No viewer available on connection");
+    const viewer = assertEx12(this.connectionInstance.viewer, () => "No viewer available on connection");
     const { nbf, exp, chain, fees } = options ?? {};
-    const resolvedChainId = isDefined9(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = isDefined9(nbf) ? nbf : await viewer?.currentBlockNumber();
-    const resolvedExp = isDefined9(exp) ? exp : resolvedNbf + 10;
+    const resolvedChainId = isDefined10(chain) ? chain : await viewer.chainId();
+    const resolvedNbf = isDefined10(nbf) ? nbf : await viewer?.currentBlockNumber();
+    const resolvedExp = isDefined10(exp) ? exp : resolvedNbf + 10;
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await (await this.signer()).address(), fees);
     return await this.addTransactionToChain(tx);
   }
   async addTransactionToChain(tx) {
     const connection = await this.gateway.connection();
     const signer = await this.gateway.signer();
-    const runner = assertEx11(connection.runner, () => "No runner available on connection");
+    const runner = assertEx12(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
     await this.addPayloadsToDataLakes(signedTx[1]);
     return [
       await runner.broadcastTransaction([
-        await PayloadBuilder10.addStorageMeta(signedTx[0]),
-        await PayloadBuilder10.addStorageMeta(signedTx[1])
+        signedTx[0],
+        signedTx[1]
       ]),
       signedTx
     ];
@@ -1879,7 +1997,7 @@ var SimpleXyoGatewayRunner = class {
       BigIntToJsonZod.parse(amount)
     ]));
     const transfer = new PayloadBuilder10({
-      schema: TransferSchema
+      schema: TransferSchema2
     }).fields({
       from,
       transfers: hexTransfers,
@@ -1976,7 +2094,7 @@ var SimpleXyoNetwork = class {
 };
 
 // src/simple/permissions/SimpleXyoPermissions.ts
-import { assertEx as assertEx12 } from "@xylabs/assert";
+import { assertEx as assertEx13 } from "@xylabs/assert";
 var SimpleXyoPermissions = class {
   static {
     __name(this, "SimpleXyoPermissions");
@@ -1988,7 +2106,7 @@ var SimpleXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx12(this._store, () => "Store must be defined to get permissions");
+    return assertEx13(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -2046,7 +2164,7 @@ var SimpleXyoPermissions = class {
 };
 
 // src/simple/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx13 } from "@xylabs/assert";
+import { assertEx as assertEx14 } from "@xylabs/assert";
 var MemoryPermissionsStore = class {
   static {
     __name(this, "MemoryPermissionsStore");
@@ -2057,7 +2175,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx13(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx14(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -2122,19 +2240,129 @@ var SimpleXyoSigner = class {
   }
 };
 
+// src/simple/timesync/SimpleTimeSyncViewer.ts
+import { assertEx as assertEx15 } from "@xylabs/assert";
+import { asHash as asHash5 } from "@xylabs/hex";
+import { isDefined as isDefined11 } from "@xylabs/typeof";
+import { asTimePayload, asXL1BlockNumber as asXL1BlockNumber5, TimeSchema } from "@xyo-network/xl1-protocol";
+var SimpleTimeSyncViewer = class {
+  static {
+    __name(this, "SimpleTimeSyncViewer");
+  }
+  blockViewer;
+  ethProvider;
+  constructor(blockViewer, ethProvider) {
+    this.blockViewer = blockViewer;
+    this.ethProvider = ethProvider;
+  }
+  async convertTime(fromDomain, toDomain, from) {
+    switch (fromDomain) {
+      case "xl1": {
+        const [block, payloads] = assertEx15(await this.blockViewer.blockByNumber(asXL1BlockNumber5(from, true)), () => "Block not found");
+        const timeSchemaIndex = block.payload_schemas.indexOf(TimeSchema);
+        const hash = timeSchemaIndex === -1 ? void 0 : block.payload_hashes[timeSchemaIndex];
+        const timePayload = asTimePayload(isDefined11(hash) ? payloads.find((p) => p._hash === hash) : void 0);
+        if (timePayload === void 0) return 0;
+        switch (toDomain) {
+          case "xl1": {
+            return timePayload.xl1 ?? 0;
+          }
+          case "epoch": {
+            return timePayload.epoch ?? 0;
+          }
+          case "ethereum": {
+            return timePayload.ethereum ?? 0;
+          }
+          default: {
+            throw new Error(`Unsupported to toDomain: ${toDomain}`);
+          }
+        }
+      }
+      default: {
+        throw new Error(`Unsupported from fromDomain: ${fromDomain}`);
+      }
+    }
+  }
+  async currentTime(domain) {
+    switch (domain) {
+      case "xl1": {
+        return [
+          "xl1",
+          (await this.blockViewer.currentBlock())?.[0].block ?? -1
+        ];
+      }
+      case "epoch": {
+        return [
+          "epoch",
+          Date.now()
+        ];
+      }
+      case "ethereum": {
+        return [
+          "ethereum",
+          await this.ethProvider?.getBlockNumber() ?? 0
+        ];
+      }
+      default: {
+        throw new Error(`Unknown time domain: ${domain}`);
+      }
+    }
+  }
+  async currentTimeAndHash(domain) {
+    switch (domain) {
+      case "xl1": {
+        const [head] = await this.blockViewer.currentBlock();
+        return [
+          head.block,
+          head._hash
+        ];
+      }
+      case "epoch": {
+        return [
+          Date.now(),
+          null
+        ];
+      }
+      case "ethereum": {
+        const provider = assertEx15(this.ethProvider, () => "Ethereum provider not configured");
+        const blockNumber = await provider.getBlockNumber() ?? 0;
+        const block = await provider.getBlock(blockNumber);
+        const blockHash = asHash5(assertEx15(block?.hash, () => "Block hash not found"), true);
+        return [
+          blockNumber,
+          blockHash
+        ];
+      }
+      default: {
+        throw new Error(`Unknown time domain: ${domain}`);
+      }
+    }
+  }
+  currentTimePayload() {
+    throw new Error("Method not implemented.");
+  }
+};
+
 // src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
-import { assertEx as assertEx14 } from "@xylabs/assert";
-import { asTimePayload, TimeSchema } from "@xyo-network/xl1-protocol";
+import { assertEx as assertEx16 } from "@xylabs/assert";
+import { asTimePayload as asTimePayload2, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol";
 async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
   const hydratedBlock = await hydrateBlock(context.store, blockHash);
-  const timePayload = asTimePayload(hydratedBlock[1].find((p) => p.schema === TimeSchema), {
+  const timePayload = asTimePayload2(hydratedBlock[1].find((p) => p.schema === TimeSchema2), {
     required: true
   });
-  return assertEx14(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx16(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 __name(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
 
+// src/viewers/StakeEvents.ts
+var StakeEventNames = [
+  "StakeAdded",
+  "StakeRemoved",
+  "StakeWithdrawn"
+];
+
 // src/wallet/generateXyoBaseWalletFromPhrase.ts
 import { HDWallet } from "@xyo-network/wallet";
 
@@ -2186,8 +2414,10 @@ export {
   MemoryPermissionsStore,
   MnemonicStringZod,
   RewardMultipliers,
+  SimpleAccountBalanceViewer,
   SimpleDataLakeRunner,
   SimpleDataLakeViewer,
+  SimpleTimeSyncViewer,
   SimpleXyoClient,
   SimpleXyoGateway,
   SimpleXyoGatewayRunner,