@xyo-network/xl1-protocol-sdk 1.12.0 → 1.12.2

package/dist/neutral/index.mjs

@@ -1,69 +1,97 @@
+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";
+import { asTransactionBoundWitnessWithStorageMeta, isBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 function allHashesPresent(hashes, payloads) {
   const payloadHashes = new Set(payloads.map((p) => p._hash));
   return hashes.every((hash) => payloadHashes.has(hash));
 }
-var tryHydrateBlock = async (archivist, hash, maxDepth = 1) => {
+__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([hash])).find(isBlockBoundWitnessWithStorageMeta);
+  const bw = (await archivist.get([
+    hash
+  ])).find(isBlockBoundWitnessWithStorageMeta);
   if (!bw) return void 0;
-  if (maxDepth === 0) return [bw, []];
+  if (maxDepth === 0) return [
+    bw,
+    []
+  ];
   const blkPayloads = await archivist.get(bw.payload_hashes);
-  if (maxDepth === 1) return [bw, blkPayloads];
+  if (maxDepth === 1) return [
+    bw,
+    blkPayloads
+  ];
   const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
   const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
   const transactionsPayloads = await archivist.get(transactionsPayloadHashes);
-  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap((p) => p._hash));
-  const allPayloads = await archivist.get([...allPayloadsHashes]);
+  const allPayloadsHashes = new Set([
+    ...blkPayloads,
+    ...transactionsPayloads
+  ].flatMap((p) => p._hash));
+  const allPayloads = await archivist.get([
+    ...allPayloadsHashes
+  ]);
   const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
-  return [bw, allPayloadsFiltered];
-};
-var hydrateBlock = async (archivist, hash, maxDepth = 1, minDepth = maxDepth) => {
+  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([hash])).find(isBlockBoundWitnessWithStorageMeta),
-    () => `block ${hash} not found`
-  );
-  if (maxDepth === 0) return [bw, []];
+  const bw = assertEx((await archivist.get([
+    hash
+  ])).find(isBlockBoundWitnessWithStorageMeta), () => `block ${hash} not found`);
+  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];
+  if (maxDepth === 1) return [
+    bw,
+    blkPayloads
+  ];
   const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
   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].flatMap((p) => p._hash));
-  const allPayloads = await archivist.get([...allPayloadsHashes]);
+  const allPayloadsHashes = new Set([
+    ...blkPayloads,
+    ...transactionsPayloads
+  ].flatMap((p) => p._hash));
+  const allPayloads = await archivist.get([
+    ...allPayloadsHashes
+  ]);
   const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
-  if (maxDepth === 2) assertEx(allHashesPresent(
-    [...allPayloadsHashes],
+  if (maxDepth === 2) assertEx(allHashesPresent([
+    ...allPayloadsHashes
+  ], allPayloadsFiltered), () => `Unable to find all payloads for transactions in block ${hash}`);
+  return [
+    bw,
     allPayloadsFiltered
-  ), () => `Unable to find all payloads for transactions in block ${hash}`);
-  return [bw, allPayloadsFiltered];
-};
-var flattenHydratedBlock = (hydratedBlock) => {
+  ];
+}, "hydrateBlock");
+var flattenHydratedBlock = /* @__PURE__ */ __name((hydratedBlock) => {
   const [blk, blkPayloads] = hydratedBlock;
-  return [...blkPayloads, blk];
-};
-var flattenHydratedBlocks = (hydratedBlocks) => hydratedBlocks.flatMap((blk) => flattenHydratedBlock(blk));
-var transactionsFromHydratedBlock = (block) => {
+  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);
-};
-var blockPayloadsFromHydratedBlock = (block) => {
-  return block[0].payload_hashes.map((hash) => assertEx(
-    block[1].find((p) => p._hash === hash),
-    () => `missing payload ${hash}`
-  )).filter((x) => !isTransactionBoundWitnessWithStorageMeta(x));
-};
+}, "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");
 
 // src/block/primitives/balanceStepSummaryFromRange.ts
 import { assertEx as assertEx2 } from "@xylabs/assert";
@@ -72,12 +100,9 @@ import { isAnyPayload } from "@xyo-network/payload-model";
 import { StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol";
 
 // src/payload/netBalancesForPayloads.ts
-import {
-  hexToBigInt,
-  toAddress
-} from "@xylabs/hex";
+import { hexToBigInt, toAddress } from "@xylabs/hex";
 import { isTransfer } from "@xyo-network/xl1-protocol";
-var netBalancesForPayloads = (payloads) => {
+var netBalancesForPayloads = /* @__PURE__ */ __name((payloads) => {
   const balances = {};
   for (const payload of payloads) {
     if (isTransfer(payload)) {
@@ -89,21 +114,18 @@ var netBalancesForPayloads = (payloads) => {
     }
   }
   return balances;
-};
+}, "netBalancesForPayloads");
 
 // src/SignedBigInt.ts
-import {
-  hexToBigInt as hexToBigInt2,
-  toHex
-} from "@xylabs/hex";
+import { hexToBigInt as hexToBigInt2, toHex } from "@xylabs/hex";
 import { isObject } from "@xylabs/object";
-var isNegativeBigInt = (value) => {
+var isNegativeBigInt = /* @__PURE__ */ __name((value) => {
   return isObject(value) && "negative" in value && typeof value.negative === "string";
-};
-var isPositiveBigInt = (value) => {
+}, "isNegativeBigInt");
+var isPositiveBigInt = /* @__PURE__ */ __name((value) => {
   return isObject(value) && "positive" in value && typeof value.positive === "string";
-};
-var parseSignedBigInt = (value) => {
+}, "isPositiveBigInt");
+var parseSignedBigInt = /* @__PURE__ */ __name((value) => {
   if (isNegativeBigInt(value)) {
     return -hexToBigInt2(value.negative);
   } else if (isPositiveBigInt(value)) {
@@ -111,22 +133,32 @@ var parseSignedBigInt = (value) => {
   } else {
     throw new Error("Invalid balance type");
   }
-};
-var toSignedBigInt = (value) => {
-  return value < 0n ? { negative: toHex(-value) } : { positive: toHex(value) };
-};
-var toPositiveBigInt = (value) => {
+}, "parseSignedBigInt");
+var toSignedBigInt = /* @__PURE__ */ __name((value) => {
+  return value < 0n ? {
+    negative: toHex(-value)
+  } : {
+    positive: toHex(value)
+  };
+}, "toSignedBigInt");
+var toPositiveBigInt = /* @__PURE__ */ __name((value) => {
   if (isNegativeBigInt(value)) {
-    return { positive: toHex(0n) };
+    return {
+      positive: toHex(0n)
+    };
   }
   if (isPositiveBigInt(value)) {
-    return { positive: value.positive };
+    return {
+      positive: value.positive
+    };
   }
   if (typeof value === "bigint") {
-    return { positive: toHex(value) };
+    return {
+      positive: toHex(value)
+    };
   }
   throw new Error("Invalid value for positive big int");
-};
+}, "toPositiveBigInt");
 
 // src/block/primitives/frames/calculateFramesFromRange.ts
 import { stepSize } from "@xyo-network/xl1-protocol";
@@ -137,23 +169,38 @@ function calculateFramesFromRange(range, step) {
   const remaining = [];
   if (start !== range[0]) {
     start += size;
-    remaining.push([range[0], Math.min(start - 1, range[1])]);
+    remaining.push([
+      range[0],
+      Math.min(start - 1, range[1])
+    ]);
   }
   for (let i = start; i <= range[1]; i += size) {
     if (i + size - 1 <= range[1]) {
-      fitted.push([i, Math.min(i + size - 1, range[1])]);
+      fitted.push([
+        i,
+        Math.min(i + size - 1, range[1])
+      ]);
     } else {
-      remaining.push([i, range[1]]);
+      remaining.push([
+        i,
+        range[1]
+      ]);
     }
   }
-  return [fitted, remaining];
+  return [
+    fitted,
+    remaining
+  ];
 }
+__name(calculateFramesFromRange, "calculateFramesFromRange");
 
 // src/block/primitives/frames/deepCalculateFramesFromRange.ts
 import { StepSizes } from "@xyo-network/xl1-protocol";
 function deepCalculateFramesFromRange(range, startingStep = StepSizes.length - 1) {
   const fitted = [];
-  let remaining = [range];
+  let remaining = [
+    range
+  ];
   for (let step = startingStep; step >= 0; step--) {
     const newRemaining = [];
     for (const range2 of remaining) {
@@ -165,19 +212,27 @@ function deepCalculateFramesFromRange(range, startingStep = StepSizes.length - 1
   }
   for (const range2 of remaining) {
     for (let i = range2[0]; i <= range2[1]; i++) {
-      fitted.push([i, i]);
+      fitted.push([
+        i,
+        i
+      ]);
     }
   }
   return fitted.toSorted((a, b) => a[0] - b[0]);
 }
+__name(deepCalculateFramesFromRange, "deepCalculateFramesFromRange");
 
 // src/block/primitives/hashFromBlockNumber.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) {
-  const result = await context.chainArchivist.get([context.head]);
-  let currentBlock = asBlockBoundWitnessWithStorageMeta(result.at(0), () => `Head block not found for hash: ${context.head}`, { required: true });
+  const result = await context.chainArchivist.get([
+    context.head
+  ]);
+  let currentBlock = asBlockBoundWitnessWithStorageMeta(result.at(0), () => `Head block not found for hash: ${context.head}`, {
+    required: true
+  });
   while (currentBlock.block > blockNumber) {
     let jumpHash = currentBlock.previous;
     let jumpBlockNumber = currentBlock.block - 1;
@@ -191,7 +246,9 @@ async function hashFromBlockNumber(context, blockNumber) {
     const [newBlock] = await context.chainArchivist.get([
       asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`)
     ]);
-    currentBlock = asBlockBoundWitnessWithStorageMeta(newBlock, () => `Block not found for hash: ${jumpHash}`, { required: true });
+    currentBlock = asBlockBoundWitnessWithStorageMeta(newBlock, () => `Block not found for hash: ${jumpHash}`, {
+      required: true
+    });
     if (currentBlock.block === blockNumber) {
       break;
     }
@@ -201,6 +258,7 @@ async function hashFromBlockNumber(context, blockNumber) {
   }
   return currentBlock._hash;
 }
+__name(hashFromBlockNumber, "hashFromBlockNumber");
 
 // src/block/primitives/payloads.ts
 import { AsObjectFactory } from "@xylabs/object";
@@ -209,9 +267,9 @@ var StepSummarySchema = "network.xyo.step.summary";
 var BalancesStepSummarySchema = "network.xyo.step.summary.balances";
 var isBalancesStepSummary = isPayloadOfSchemaType(BalancesStepSummarySchema);
 var asBalancesStepSummary = AsObjectFactory.create(isBalancesStepSummary);
-var isBalancesStepSummaryWithStorageMeta = (value) => {
+var isBalancesStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
   return isBalancesStepSummary(value) && isStorageMeta(value);
-};
+}, "isBalancesStepSummaryWithStorageMeta");
 var asBalancesStepSummaryWithStorageMeta = AsObjectFactory.create(isBalancesStepSummaryWithStorageMeta);
 
 // src/block/primitives/balanceStepSummaryFromRange.ts
@@ -235,15 +293,14 @@ async function balanceStepSummaryFromRange(context, range) {
   } else {
     const step = StepSizes3.indexOf(frameSize);
     assertEx2(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes3.join(", ")}`);
-    const [summaryResult] = await context.summaryRepository.get([frameHeadHash]);
+    const [summaryResult] = await context.summaryRepository.get([
+      frameHeadHash
+    ]);
     if (isAnyPayload(summaryResult)) {
       result = summaryResult;
     } else {
       const subRanges = deepCalculateFramesFromRange(range, step - 1);
-      const promises = subRanges.map((subRange) => balanceStepSummaryFromRange(
-        context,
-        subRange
-      ));
+      const promises = subRanges.map((subRange) => balanceStepSummaryFromRange(context, subRange));
       const subResults = await Promise.all(promises);
       const bigIntBalances = {};
       for (const subResult of subResults) {
@@ -261,22 +318,32 @@ async function balanceStepSummaryFromRange(context, range) {
         stepSize: frameSize,
         balances
       };
-      await context.summaryRepository.insert([result]);
+      await context.summaryRepository.insert([
+        result
+      ]);
     }
   }
   const finalResult = await PayloadBuilder.addStorageMeta(result);
   return finalResult;
 }
+__name(balanceStepSummaryFromRange, "balanceStepSummaryFromRange");
 
 // src/block/primitives/balanceSummary.ts
 import { asAddress } from "@xylabs/hex";
 import { isDefined } from "@xylabs/typeof";
 import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2 } from "@xyo-network/xl1-protocol";
 async function balanceSummary(context) {
-  const headResult = await context.chainArchivist.get([context.head]);
-  const headBoundWitness = asBlockBoundWitnessWithStorageMeta2(headResult.at(0), () => `Head block not found for hash: ${context.head}`, { required: true });
+  const headResult = await context.chainArchivist.get([
+    context.head
+  ]);
+  const headBoundWitness = asBlockBoundWitnessWithStorageMeta2(headResult.at(0), () => `Head block not found for hash: ${context.head}`, {
+    required: true
+  });
   const rangeStart = isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0;
-  const ranges = deepCalculateFramesFromRange([rangeStart, headBoundWitness.block]);
+  const ranges = deepCalculateFramesFromRange([
+    rangeStart,
+    headBoundWitness.block
+  ]);
   const summaries = await Promise.all(ranges.map((range) => balanceStepSummaryFromRange(context, range)));
   const balances = {};
   for (let summary of summaries) {
@@ -287,33 +354,40 @@ async function balanceSummary(context) {
   }
   return balances;
 }
+__name(balanceSummary, "balanceSummary");
 
 // src/config/Config.ts
-import z11 from "zod";
+import * as z11 from "zod";
 
 // src/config/Api.ts
-import z2, { globalRegistry } from "zod";
+import { globalRegistry } from "zod";
+import * as z2 from "zod";
 
 // src/validation/lib/isLocalhost.ts
-var isLocalhost = (hostname) => {
+var isLocalhost = /* @__PURE__ */ __name((hostname) => {
   return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost");
-};
+}, "isLocalhost");
 
 // src/validation/lib/getUrl.ts
-var getUrl = (host, port) => {
+var getUrl = /* @__PURE__ */ __name((host, port) => {
   const scheme = isLocalhost(host) ? "http" : "https";
   return `${scheme}://${host}:${port}`;
-};
+}, "getUrl");
 
 // src/validation/schema/Address.ts
 var TODO = true;
 
 // src/validation/schema/Mnemonic.ts
-import { z } from "zod";
-var MnemonicStringZod = z.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
-  (s) => [12, 15, 18, 21, 24].includes(s.split(" ").length),
-  { message: "Mnemonic must contain 12, 15, 18, 21, or 24 words." }
-).describe("BIP-39 mnemonic string");
+import * as z from "zod";
+var MnemonicStringZod = z.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine((s) => [
+  12,
+  15,
+  18,
+  21,
+  24
+].includes(s.split(" ").length), {
+  message: "Mnemonic must contain 12, 15, 18, 21, or 24 words."
+}).describe("BIP-39 mnemonic string");
 
 // src/config/Api.ts
 var ApiConfigZod = z2.object({
@@ -337,7 +411,8 @@ var ApiConfigZod = z2.object({
 });
 
 // src/config/App.ts
-import z3, { globalRegistry as globalRegistry2 } from "zod";
+import { globalRegistry as globalRegistry2 } from "zod";
+import * as z3 from "zod";
 var AppConfigZod = z3.object({
   port: z3.coerce.number().default(3e3).register(globalRegistry2, {
     default: 3e3,
@@ -348,7 +423,8 @@ var AppConfigZod = z3.object({
 });
 
 // src/config/Chain.ts
-import z4, { globalRegistry as globalRegistry3 } from "zod";
+import { globalRegistry as globalRegistry3 } from "zod";
+import * as z4 from "zod";
 var ChainConfigZod = z4.object({
   id: z4.string().optional().register(globalRegistry3, {
     description: "The unique identifier for the chain. Should be the staking contract address for contract-backed chains.",
@@ -358,7 +434,8 @@ var ChainConfigZod = z4.object({
 });
 
 // src/config/Evm.ts
-import z5, { globalRegistry as globalRegistry4 } from "zod";
+import { globalRegistry as globalRegistry4 } from "zod";
+import * as z5 from "zod";
 var EvmInfuraConfigZod = z5.object({
   projectId: z5.string().optional().register(globalRegistry4, {
     description: "Infura project ID",
@@ -390,7 +467,8 @@ var EvmConfigZod = z5.object({
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/logger";
-import z6, { globalRegistry as globalRegistry5 } from "zod";
+import { globalRegistry as globalRegistry5 } from "zod";
+import * as z6 from "zod";
 var LogLevels = Object.keys(LogLevel);
 var LogConfigZod = z6.object({
   logLevel: z6.enum(LogLevels).default("info").register(globalRegistry5, {
@@ -409,7 +487,8 @@ var LogConfigZod = z6.object({
 });
 
 // src/config/Producer.ts
-import z7, { globalRegistry as globalRegistry6 } from "zod";
+import { globalRegistry as globalRegistry6 } from "zod";
+import * as z7 from "zod";
 var ProducerConfigZod = z7.object({
   disableIntentRedeclaration: z7.boolean().optional().register(globalRegistry6, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
@@ -450,11 +529,12 @@ var ProducerConfigZod = z7.object({
 
 // src/config/storage/driver/Mongo.ts
 import { isDefined as isDefined2, isUndefined } from "@xylabs/typeof";
-import z8, { globalRegistry as globalRegistry7 } from "zod";
-var hasMongoConfig = (config) => {
+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);
-};
+}, "hasMongoConfig");
 var MongoConfigZod = z8.object({
   // TODO: Create from other arguments
   connectionString: z8.string().min(1).optional().register(globalRegistry7, {
@@ -485,7 +565,8 @@ var MongoConfigZod = z8.object({
 });
 
 // src/config/storage/Storage.ts
-import z9, { globalRegistry as globalRegistry8 } from "zod";
+import { globalRegistry as globalRegistry8 } from "zod";
+import * as z9 from "zod";
 var StorageConfigZod = z9.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
   root: z9.string().optional().register(globalRegistry8, {
@@ -496,7 +577,8 @@ var StorageConfigZod = z9.object({
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import z10, { globalRegistry as globalRegistry9 } from "zod";
+import { globalRegistry as globalRegistry9 } from "zod";
+import * as z10 from "zod";
 var OpenTelemetryConfigZod = z10.object({
   // OpenTelemetry options
   otlpEndpoint: z10.url().optional().register(globalRegistry9, {
@@ -511,7 +593,9 @@ var TelemetryConfigZod = z10.object({
 }).describe("Telemetry configuration options");
 
 // src/config/Config.ts
-var Xl1CommonConfigSchema = z11.object({ ...LogConfigZod.shape }).describe("XL1 common configuration options");
+var Xl1CommonConfigSchema = z11.object({
+  ...LogConfigZod.shape
+}).describe("XL1 common configuration options");
 var ConfigZod = z11.object({
   ...Xl1CommonConfigSchema.shape,
   api: ApiConfigZod.default(ApiConfigZod.parse({})).describe("Configuration for the API node"),
@@ -522,10 +606,10 @@ var ConfigZod = z11.object({
   storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe("Configuration for the storage"),
   telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe("Configuration for telemetry")
 });
-var getDefaultConfig = () => ConfigZod.parse({});
+var getDefaultConfig = /* @__PURE__ */ __name(() => ConfigZod.parse({}), "getDefaultConfig");
 
 // src/config/UsageMeta.ts
-import z12 from "zod";
+import * as z12 from "zod";
 var DescriptionSchema = z12.string();
 var TitleSchema = z12.string();
 var JSONSchemaMetaSchema = z12.object({
@@ -535,7 +619,12 @@ var JSONSchemaMetaSchema = z12.object({
   deprecated: z12.boolean().optional()
 }).catchall(z12.unknown());
 var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
-var ChoicesSchema = z12.array(z12.union([z12.string(), z12.number(), z12.literal(true), z12.undefined()])).readonly();
+var ChoicesSchema = z12.array(z12.union([
+  z12.string(),
+  z12.number(),
+  z12.literal(true),
+  z12.undefined()
+])).readonly();
 var UsageMetaSchema = GlobalMetaSchema.extend({
   choices: ChoicesSchema.optional(),
   default: z12.unknown().optional(),
@@ -554,6 +643,7 @@ var UsageMetaSchema = GlobalMetaSchema.extend({
 function isUsageMeta(v) {
   return UsageMetaSchema.safeParse(v).success;
 }
+__name(isUsageMeta, "isUsageMeta");
 
 // src/transaction/buildTransaction.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
@@ -588,9 +678,20 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
   if (script.length > 0) {
     fields.script = script;
   }
-  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({ $signatures: [] }).payloads([...onChainPayloads, ...offChainPayloads]).signers(Array.isArray(signer) ? signer : [signer]).build();
-  return [await PayloadBuilder2.addStorageMeta(tx), await PayloadBuilder2.addStorageMeta(txPayloads)];
+  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({
+    $signatures: []
+  }).payloads([
+    ...onChainPayloads,
+    ...offChainPayloads
+  ]).signers(Array.isArray(signer) ? signer : [
+    signer
+  ]).build();
+  return [
+    await PayloadBuilder2.addStorageMeta(tx),
+    await PayloadBuilder2.addStorageMeta(txPayloads)
+  ];
 }
+__name(buildTransaction, "buildTransaction");
 
 // src/transaction/buildUnsignedTransaction.ts
 import { toHex as toHex3 } from "@xylabs/hex";
@@ -621,9 +722,18 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
   if (script.length > 0) {
     fields.script = script;
   }
-  const [tx, txPayloads] = await new BoundWitnessBuilder2().fields(fields).meta({ $signatures: [] }).payloads([...onChainPayloads, ...offChainPayloads]).build();
-  return [await PayloadBuilder3.addStorageMeta(tx), await PayloadBuilder3.addStorageMeta(txPayloads)];
+  const [tx, txPayloads] = await new BoundWitnessBuilder2().fields(fields).meta({
+    $signatures: []
+  }).payloads([
+    ...onChainPayloads,
+    ...offChainPayloads
+  ]).build();
+  return [
+    await PayloadBuilder3.addStorageMeta(tx),
+    await PayloadBuilder3.addStorageMeta(txPayloads)
+  ];
 }
+__name(buildUnsignedTransaction, "buildUnsignedTransaction");
 
 // src/transaction/confirmSubmittedTransaction.ts
 import { delay } from "@xylabs/delay";
@@ -631,7 +741,7 @@ import { isDefined as isDefined3 } from "@xylabs/typeof";
 import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
-var confirmSubmittedTransaction = async (viewer, transaction, options) => {
+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);
   options?.logger?.log("\u{1F680} confirming transaction:", txBWHash, "\n");
@@ -652,32 +762,27 @@ var confirmSubmittedTransaction = async (viewer, transaction, options) => {
       }
     }
   }
-};
+}, "confirmSubmittedTransaction");
 
 // src/transaction/hydrateTransaction.ts
 import { assertEx as assertEx4 } from "@xylabs/assert";
 import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from "@xyo-network/archivist-model";
 import { isAllowedBlockPayload, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
-var tryHydrateTransaction = async (archivist, hash) => {
-  return await tryHydrateTypedBoundWitness(
-    archivist,
-    hash,
-    isSignedTransactionBoundWitnessWithStorageMeta
-  );
-};
-var hydrateTransaction = async (archivist, hash) => {
-  return await hydrateTypedBoundWitness(
-    archivist,
-    hash,
-    isSignedTransactionBoundWitnessWithStorageMeta
-  );
-};
-var flattenHydratedTransaction = (hydratedTransaction) => {
+var tryHydrateTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
+  return await tryHydrateTypedBoundWitness(archivist, hash, isSignedTransactionBoundWitnessWithStorageMeta);
+}, "tryHydrateTransaction");
+var hydrateTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
+  return await hydrateTypedBoundWitness(archivist, hash, isSignedTransactionBoundWitnessWithStorageMeta);
+}, "hydrateTransaction");
+var flattenHydratedTransaction = /* @__PURE__ */ __name((hydratedTransaction) => {
   const [tx, txPayloads] = hydratedTransaction;
-  return [...txPayloads, tx];
-};
-var flattenHydratedTransactions = (hydratedTransactions) => hydratedTransactions.flatMap((tx) => flattenHydratedTransaction(tx));
-var tryHydrateElevatedTransaction = async (archivist, hash) => {
+  return [
+    ...txPayloads,
+    tx
+  ];
+}, "flattenHydratedTransaction");
+var flattenHydratedTransactions = /* @__PURE__ */ __name((hydratedTransactions) => hydratedTransactions.flatMap((tx) => flattenHydratedTransaction(tx)), "flattenHydratedTransactions");
+var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
   const hydratedTransaction = await tryHydrateTransaction(archivist, hash);
   if (!hydratedTransaction) {
     return void 0;
@@ -695,13 +800,16 @@ var tryHydrateElevatedTransaction = async (archivist, hash) => {
     }
   }
   if (opCodes.length === elevatedPayloads.length) {
-    return [transaction, elevatedPayloads];
+    return [
+      transaction,
+      elevatedPayloads
+    ];
   }
   return void 0;
-};
-var hydrateElevatedTransaction = async (archivist, hash) => {
+}, "tryHydrateElevatedTransaction");
+var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
   return assertEx4(await tryHydrateElevatedTransaction(archivist, hash), () => "Hydration failed");
-};
+}, "hydrateElevatedTransaction");
 
 // src/transaction/primitives/transactionBlockByteCount.ts
 import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
@@ -711,6 +819,7 @@ function transactionBlockByteCount([transaction, payloads]) {
   const cleanPayloads = PayloadBuilder5.omitStorageMeta(payloads);
   return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
 }
+__name(transactionBlockByteCount, "transactionBlockByteCount");
 
 // src/transaction/primitives/transactionElevatedPayloads.ts
 import { asHash as asHash2 } from "@xylabs/hex";
@@ -721,65 +830,77 @@ function crackOperation(operation) {
   if (parts.length < 2) {
     throw new Error(`Invalid operation format: ${operation}`);
   }
-  return [parts[0], parts.slice(1)];
+  return [
+    parts[0],
+    parts.slice(1)
+  ];
 }
+__name(crackOperation, "crackOperation");
 function crackOperations(operations) {
   return operations.map((op) => crackOperation(op));
 }
+__name(crackOperations, "crackOperations");
 
 // src/transaction/primitives/transactionElevatedPayloads.ts
 function transactionElevatedPayloadHashes(transaction) {
   const elevateOperations = crackOperations(transaction.script ?? []).filter((op) => op[0] === "elevate");
   return elevateOperations.map((op) => asHash2(op[1][0], true));
 }
+__name(transactionElevatedPayloadHashes, "transactionElevatedPayloadHashes");
 function transactionElevatedPayloads([transaction, payloads]) {
   const hashes = transactionElevatedPayloadHashes(transaction);
   const elevatedPayloads = payloads.filter((payload) => hashes.includes(payload._hash));
   return elevatedPayloads;
 }
+__name(transactionElevatedPayloads, "transactionElevatedPayloads");
 
 // src/transaction/primitives/transactionRequiredGas.ts
 import { AttoXL1, TransactionGasCosts } from "@xyo-network/xl1-protocol";
 function transactionBytesRequiredGas([transaction, payloads]) {
-  const transactionBlockBytes = transactionBlockByteCount([transaction, payloads]);
+  const transactionBlockBytes = transactionBlockByteCount([
+    transaction,
+    payloads
+  ]);
   return AttoXL1(TransactionGasCosts.characterStorage * BigInt(transactionBlockBytes));
 }
+__name(transactionBytesRequiredGas, "transactionBytesRequiredGas");
 function transactionRequiredGas(hydratedTransaction) {
   const elevatedPayloads = transactionElevatedPayloads(hydratedTransaction);
   const hashes = elevatedPayloads.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));
 }
+__name(transactionRequiredGas, "transactionRequiredGas");
 
 // src/transaction/script.ts
 import { filterAs as filterAs2 } from "@xylabs/array";
 import { assertEx as assertEx5 } from "@xylabs/assert";
 import { asHash as asHash3 } from "@xylabs/hex";
 import { isAllowedBlockPayloadWithHashStorageMeta } from "@xyo-network/xl1-protocol";
-var tryExtractElevatedHashesFromScript = (strings) => {
+var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
   return filterAs2(hashes, (h) => asHash3(h));
-};
-var extractElevatedHashesFromScript = (strings) => {
+}, "tryExtractElevatedHashesFromScript");
+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");
   return filtered;
-};
-var tryExtractElevatedHashes = (tx) => {
+}, "extractElevatedHashesFromScript");
+var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const [bw, payloads] = tx;
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
   return payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashStorageMeta);
-};
-var extractElevatedHashes = (tx) => {
+}, "tryExtractElevatedHashes");
+var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const [bw, payloads] = 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");
   return filtered;
-};
+}, "extractElevatedHashes");
 
 // src/transaction/signTransaction.ts
 import { toArrayBuffer } from "@xylabs/arraybuffer";
@@ -789,31 +910,49 @@ import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder"
 async function signTransaction(tx, account) {
   assertEx6(tx.from === account.address, () => "Signer address does not match transaction from address");
   const signedTx = structuredClone(tx);
-  signedTx.addresses = [account.address];
-  signedTx.previous_hashes = [account.previousHash ?? null];
-  const hash = await PayloadBuilder6.hash(signedTx);
+  signedTx.addresses = [
+    account.address
+  ];
+  signedTx.previous_hashes = [
+    account.previousHash ?? null
+  ];
+  const hash = await PayloadBuilder6.dataHash(signedTx);
   const hashBytes = toArrayBuffer(hash);
   const [signature] = await account.sign(hashBytes);
-  signedTx.$signatures = [hexFromArrayBuffer(signature)];
+  signedTx.$signatures = [
+    hexFromArrayBuffer(signature)
+  ];
   return signedTx;
 }
+__name(signTransaction, "signTransaction");
 
 // src/wallet/generateXyoBaseWalletFromPhrase.ts
 import { HDWallet } from "@xyo-network/wallet";
 
 // src/wallet/paths.ts
 var WALLET_COMPLIANCE = "44'";
-var COIN_TYPES = { Ethereum: "60'" };
-var ACCOUNT_TYPE = { GANACHE: "0'", XYO: "0'" };
-var CHANGE_ADDRESS = { META_MASK: "0", XYO: "0" };
-var ADDRESS_INDEX = { META_MASK: "0", XYO: "0" };
+var COIN_TYPES = {
+  Ethereum: "60'"
+};
+var ACCOUNT_TYPE = {
+  GANACHE: "0'",
+  XYO: "0'"
+};
+var CHANGE_ADDRESS = {
+  META_MASK: "0",
+  XYO: "0"
+};
+var ADDRESS_INDEX = {
+  META_MASK: "0",
+  XYO: "0"
+};
 var DEFAULT_WALLET_PATH = `m/${WALLET_COMPLIANCE}/${COIN_TYPES.Ethereum}/${ACCOUNT_TYPE.XYO}/${CHANGE_ADDRESS.XYO}`;
 
 // src/wallet/generateXyoBaseWalletFromPhrase.ts
-var generateXyoBaseWalletFromPhrase = (walletPhrase) => {
+var generateXyoBaseWalletFromPhrase = /* @__PURE__ */ __name((walletPhrase) => {
   const wallet = HDWallet.fromPhrase(walletPhrase, DEFAULT_WALLET_PATH);
   return wallet;
-};
+}, "generateXyoBaseWalletFromPhrase");
 export {
   ACCOUNT_TYPE,
   ADDRESS_INDEX,