@xyo-network/xl1-protocol-sdk 1.5.34 → 1.5.36

package/dist/neutral/index.mjs

@@ -10,20 +10,38 @@ function allHashesPresent(hashes, payloads) {
   return hashes.every((hash) => payloadHashes.has(hash));
 }
 __name(allHashesPresent, "allHashesPresent");
-var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1, minDepth) => {
-  try {
-    return await hydrateBlock(archivist, hash, maxDepth, minDepth);
-  } catch (e) {
-    if (e instanceof Error) {
-      console.warn(`Failed to hydrate block ${hash}: ${e.message}`);
-    } else {
-      console.warn(`Failed to hydrate block ${hash}: ${e}`);
-    }
-    return void 0;
-  }
+var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1) => {
+  assertEx(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
+  const bw = filterAs(await archivist.get([
+    hash
+  ]), asBlockBoundWitnessWithStorageMeta).at(0);
+  if (!bw) return void 0;
+  if (maxDepth === 0) return [
+    bw,
+    []
+  ];
+  const blkPayloads = await archivist.get(bw.payload_hashes);
+  if (maxDepth === 1) return [
+    bw,
+    blkPayloads
+  ];
+  const transactions = filterAs(blkPayloads, asTransactionBoundWitnessWithStorageMeta);
+  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 allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
+  return [
+    bw,
+    allPayloadsFiltered
+  ];
 }, "tryHydrateBlock");
-var hydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1, minDepth) => {
-  if (minDepth === void 0) minDepth = maxDepth;
+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");
@@ -75,119 +93,267 @@ 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/frames/stepHashFramesFromBlock.ts
+// src/block/primitives/balanceStepSummaryFromRange.ts
 import { assertEx as assertEx2 } from "@xylabs/assert";
-import { isHash } from "@xylabs/hex";
-import { isDefined } from "@xylabs/typeof";
-import { isBlockBoundWitness, StepSizes } from "@xyo-network/xl1-protocol";
-async function stepHashFramesFromBlockAtSize(archivist, head, sizeIndex) {
-  if (!Number.isInteger(sizeIndex) || sizeIndex < 0 || sizeIndex >= StepSizes.length) {
-    throw new Error(`Invalid sizeIndex: ${sizeIndex}`);
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+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 { isTransfer } from "@xyo-network/xl1-protocol";
+var netBalancesForPayloads = /* @__PURE__ */ __name((payloads) => {
+  const balances = {};
+  for (const payload of payloads) {
+    if (isTransfer(payload)) {
+      const { from } = payload;
+      for (let [address, amount] of Object.entries(payload.transfers)) {
+        balances[toAddress(address)] = (balances[toAddress(address)] ?? 0n) + hexToBigInt(amount);
+        balances[toAddress(from)] = (balances[toAddress(from)] ?? 0n) - hexToBigInt(amount);
+      }
+    }
+  }
+  return balances;
+}, "netBalancesForPayloads");
+
+// src/SignedBigInt.ts
+import { hexToBigInt as hexToBigInt2, toHex } from "@xylabs/hex";
+import { isObject } from "@xylabs/object";
+var isNegativeBigInt = /* @__PURE__ */ __name((value) => {
+  return isObject(value) && "negative" in value && typeof value.negative === "string";
+}, "isNegativeBigInt");
+var isPositiveBigInt = /* @__PURE__ */ __name((value) => {
+  return isObject(value) && "positive" in value && typeof value.positive === "string";
+}, "isPositiveBigInt");
+var parseSignedBigInt = /* @__PURE__ */ __name((value) => {
+  if (isNegativeBigInt(value)) {
+    return -hexToBigInt2(value.negative);
+  } else if (isPositiveBigInt(value)) {
+    return hexToBigInt2(value.positive);
+  } else {
+    throw new Error("Invalid balance type");
+  }
+}, "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)
+    };
+  }
+  if (isPositiveBigInt(value)) {
+    return {
+      positive: value.positive
+    };
+  }
+  if (typeof value === "bigint") {
+    return {
+      positive: toHex(value)
+    };
   }
-  let currentHead = head;
-  const steps = [];
-  while (isHash(currentHead)) {
-    const [block] = await archivist.get([
-      currentHead
+  throw new Error("Invalid value for positive big int");
+}, "toPositiveBigInt");
+
+// src/block/primitives/frames/deepCalculateFramesFromRange.ts
+import { StepSizes } from "@xyo-network/xl1-protocol";
+
+// src/block/primitives/frames/calculateFramesFromRange.ts
+import { stepSize } from "@xyo-network/xl1-protocol";
+function calculateFramesFromRange(range, step) {
+  const size = stepSize(step);
+  let start = Math.trunc(range[0] / size) * size;
+  const fitted = [];
+  const remaining = [];
+  if (start !== range[0]) {
+    start += size;
+    remaining.push([
+      range[0],
+      Math.min(start - 1, range[1])
     ]);
-    if (!isBlockBoundWitness(block)) {
-      throw new Error(`Block with hash ${currentHead} not found`);
-    }
-    let stepHash = block.step_hashes.at(sizeIndex);
-    while (isDefined(stepHash)) {
-      const [stepHashBlock] = await archivist.get([
-        stepHash
+  }
+  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])
       ]);
-      if (!isBlockBoundWitness(stepHashBlock)) {
-        throw new Error(`StepHashBlock with hash ${currentHead} not found`);
-      }
-      const [lastBlockInStep] = await archivist.get([
-        assertEx2(stepHashBlock.previous, () => "StepHashBlock must have a previous block")
+    } else {
+      remaining.push([
+        i,
+        range[1]
       ]);
-      if (!isBlockBoundWitness(lastBlockInStep)) {
-        throw new Error(`StepHashBlock with hash ${currentHead} not found`);
-      }
-      steps.push([
-        stepHash,
-        stepHashBlock.block - StepSizes[sizeIndex],
-        stepHashBlock.block - 1
+    }
+  }
+  return [
+    fitted,
+    remaining
+  ];
+}
+__name(calculateFramesFromRange, "calculateFramesFromRange");
+
+// src/block/primitives/frames/deepCalculateFramesFromRange.ts
+function deepCalculateFramesFromRange(range, startingStep = StepSizes.length - 1) {
+  const fitted = [];
+  let remaining = [
+    range
+  ];
+  for (let step = startingStep; step >= 0; step--) {
+    const newRemaining = [];
+    for (const range2 of remaining) {
+      const [newFittedFrames, newRemainingFrames] = calculateFramesFromRange(range2, step);
+      fitted.push(...newFittedFrames);
+      newRemaining.push(...newRemainingFrames);
+    }
+    remaining = newRemaining;
+  }
+  for (const range2 of remaining) {
+    for (let i = range2[0]; i <= range2[1]; i++) {
+      fitted.push([
+        i,
+        i
       ]);
-      stepHash = lastBlockInStep.step_hashes.at(sizeIndex);
     }
   }
-  return steps;
+  return fitted.toSorted((a, b) => a[0] - b[0]);
 }
-__name(stepHashFramesFromBlockAtSize, "stepHashFramesFromBlockAtSize");
-async function stepHashFramesFromBlock(archivist, head) {
-  const [block] = await archivist.get([
-    head
+__name(deepCalculateFramesFromRange, "deepCalculateFramesFromRange");
+
+// src/block/primitives/hashFromBlockNumber.ts
+import { asHash } from "@xylabs/hex";
+import { toJsonString } from "@xylabs/object";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, StepSizes as StepSizes2 } from "@xyo-network/xl1-protocol";
+async function hashFromBlockNumber(context, blockNumber) {
+  const result = await context.chainArchivist.get([
+    context.head
   ]);
-  if (!isBlockBoundWitness(block)) {
-    throw new Error(`Block with hash ${head} not found`);
+  let currentBlock = asBlockBoundWitnessWithStorageMeta2(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;
+    for (const [step, stepSize2] of StepSizes2.entries()) {
+      const possibleJumpBlockNumber = currentBlock.block - stepSize2;
+      if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
+        jumpBlockNumber = possibleJumpBlockNumber;
+        jumpHash = asHash(currentBlock.step_hashes.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`);
+      }
+    }
+    const [newBlock] = await context.chainArchivist.get([
+      asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toJsonString(currentBlock, 10)}`)
+    ]);
+    currentBlock = asBlockBoundWitnessWithStorageMeta2(newBlock, () => `Block not found for hash: ${jumpHash}`, {
+      required: true
+    });
+    if (currentBlock.block === blockNumber) {
+      break;
+    }
+    if (currentBlock.block < blockNumber) {
+      throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${context.head}.`);
+    }
   }
-  let availableRanges = [
-    [
-      0,
-      block.block
-    ]
-  ];
-  const foundRanges = [];
-  for (let i = StepSizes.length - 1; i >= 0; i--) {
-    const steps = await stepHashFramesFromBlockAtSize(archivist, head, i);
-    for (let step of steps) {
-      const [, start, end] = step;
-      if (availableRanges.some((range) => range[0] <= start && range[1] >= end)) {
-        foundRanges.push(step);
-        availableRanges = availableRanges.flatMap((range) => {
-          if (range[0] >= start && range[1] <= end) {
-            return [
-              [
-                range[0],
-                start - 1
-              ]
-            ];
-          } else if (range[0] < start && range[1] >= end) {
-            return [
-              [
-                range[0],
-                start - 1
-              ],
-              [
-                end + 1,
-                range[1]
-              ]
-            ];
-          } else if (range[0] < start && range[1] < end) {
-            return [
-              [
-                range[0],
-                start - 1
-              ]
-            ];
-          } else if (range[0] > start && range[1] > end) {
-            return [
-              [
-                end + 1,
-                range[1]
-              ]
-            ];
-          }
-          return [
-            range
-          ];
-        });
+  return currentBlock._hash;
+}
+__name(hashFromBlockNumber, "hashFromBlockNumber");
+
+// src/block/primitives/payloads.ts
+var StepSummarySchema = "network.xyo.step.summary";
+var BalancesStepSummarySchema = "network.xyo.step.summary.balances";
+
+// src/block/primitives/balanceStepSummaryFromRange.ts
+async function balanceStepSummaryFromRange(context, range) {
+  const frameHeadHash = await hashFromBlockNumber(context, range[1]);
+  const frameSize = range[1] - range[0] + 1;
+  let result = void 0;
+  if (frameSize === 1) {
+    const [, payloads] = await hydrateBlock(context.chainArchivist, context.head);
+    const balances = {};
+    for (const [address, balance] of Object.entries(netBalancesForPayloads(payloads))) {
+      balances[address] = toSignedBigInt(balance);
+    }
+    result = {
+      schema: BalancesStepSummarySchema,
+      hash: context.head,
+      stepSize: -1,
+      balances
+    };
+  } 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
+    ]);
+    if (isAnyPayload(summaryResult)) {
+      result = summaryResult;
+    } else {
+      const subRanges = deepCalculateFramesFromRange(range, step - 1);
+      const promises = subRanges.map((subRange) => balanceStepSummaryFromRange(context, subRange));
+      const subResults = await Promise.all(promises);
+      const bigIntBalances = {};
+      for (const subResult of subResults) {
+        for (const [address, balance] of Object.entries(subResult.balances)) {
+          bigIntBalances[address] = (bigIntBalances[address] ?? 0n) + parseSignedBigInt(balance);
+        }
       }
+      const balances = {};
+      for (const [address, balance] of Object.entries(bigIntBalances)) {
+        balances[address] = toSignedBigInt(balance);
+      }
+      result = {
+        schema: BalancesStepSummarySchema,
+        hash: frameHeadHash,
+        stepSize: frameSize,
+        balances
+      };
+      await context.summaryRepository.insert([
+        result
+      ]);
     }
   }
-  return foundRanges;
+  const finalResult = await PayloadBuilder.addStorageMeta(result);
+  return finalResult;
 }
-__name(stepHashFramesFromBlock, "stepHashFramesFromBlock");
+__name(balanceStepSummaryFromRange, "balanceStepSummaryFromRange");
+
+// src/block/primitives/balanceSummary.ts
+import { asAddress } from "@xylabs/hex";
+import { isDefined } from "@xylabs/typeof";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3 } from "@xyo-network/xl1-protocol";
+async function balanceSummary(context) {
+  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 = isDefined(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) => balanceStepSummaryFromRange(context, range)));
+  const balances = {};
+  for (let summary of summaries) {
+    for (const [address, balance] of Object.entries(summary.balances)) {
+      const validAddress = asAddress(address, () => `Invalid address: ${address}`);
+      balances[validAddress] = (balances[validAddress] ?? 0n) + parseSignedBigInt(balance);
+    }
+  }
+  return balances;
+}
+__name(balanceSummary, "balanceSummary");
 
 // src/transaction/buildTransaction.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
-import { toHex } from "@xylabs/hex";
+import { toHex as toHex2 } from "@xylabs/hex";
 import { BoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 import { defaultTransactionFees } from "@xyo-network/xl1-protocol";
 async function buildTransaction(chain, elevatedPayloads, additionalPayloads, signer, nbf, exp, from, fees = defaultTransactionFees) {
   if (from === void 0 && Array.isArray(signer)) {
@@ -196,24 +362,27 @@ async function buildTransaction(chain, elevatedPayloads, additionalPayloads, sig
   const txBoundWitnessFields = {
     chain,
     fees: {
-      base: toHex(fees.base),
-      gasLimit: toHex(fees.gasLimit),
-      gasPrice: toHex(fees.gasPrice),
-      priority: toHex(fees.priority)
+      base: toHex2(fees.base),
+      gasLimit: toHex2(fees.gasLimit),
+      gasPrice: toHex2(fees.gasPrice),
+      priority: toHex2(fees.priority)
     },
     nbf,
     exp
   };
-  const elevatedHashes = await PayloadBuilder.hashes(elevatedPayloads);
+  const elevatedHashes = await PayloadBuilder2.hashes(elevatedPayloads);
   const script = [];
   for (const elevatedHash of elevatedHashes) {
     script.push(`elevate|${elevatedHash}`);
   }
-  const [tx, txPayloads] = await new BoundWitnessBuilder().fields({
+  const fields = {
     ...txBoundWitnessFields,
-    script,
     from: from ?? (Array.isArray(signer) ? assertEx3(signer.at(0)?.address) : signer.address)
-  }).meta({
+  };
+  if (script.length > 0) {
+    fields.script = script;
+  }
+  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({
     $signatures: []
   }).payloads([
     ...elevatedPayloads,
@@ -222,8 +391,8 @@ async function buildTransaction(chain, elevatedPayloads, additionalPayloads, sig
     signer
   ]).build();
   return [
-    await PayloadBuilder.addStorageMeta(tx),
-    await PayloadBuilder.addStorageMeta(txPayloads)
+    await PayloadBuilder2.addStorageMeta(tx),
+    await PayloadBuilder2.addStorageMeta(txPayloads)
   ];
 }
 __name(buildTransaction, "buildTransaction");
@@ -276,17 +445,17 @@ var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (archivist, hash)
 }, "hydrateElevatedTransaction");
 
 // src/transaction/primitives/transactionBlockByteCount.ts
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
 function transactionBlockByteCount([transaction, payloads]) {
-  const cleanTransaction = PayloadBuilder2.omitStorageMeta(transaction);
+  const cleanTransaction = PayloadBuilder3.omitStorageMeta(transaction);
   const transactionBytes = JSON.stringify(cleanTransaction).length;
-  const cleanPayloads = PayloadBuilder2.omitStorageMeta(payloads);
+  const cleanPayloads = PayloadBuilder3.omitStorageMeta(payloads);
   return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
 }
 __name(transactionBlockByteCount, "transactionBlockByteCount");
 
 // src/transaction/primitives/transactionElevatedPayloads.ts
-import { asHash } from "@xylabs/hex";
+import { asHash as asHash2 } from "@xylabs/hex";
 
 // src/transaction/primitives/transactionOperations.ts
 function crackOperation(operation) {
@@ -308,7 +477,7 @@ __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) => asHash(op[1][0], true));
+  return elevateOperations.map((op) => asHash2(op[1][0], true));
 }
 __name(transactionElevatedPayloadHashes, "transactionElevatedPayloadHashes");
 function transactionElevatedPayloads([transaction, payloads]) {
@@ -336,20 +505,31 @@ function transactionRequiredGas(hydratedTransaction) {
 }
 __name(transactionRequiredGas, "transactionRequiredGas");
 export {
+  BalancesStepSummarySchema,
+  StepSummarySchema,
   allHashesPresent,
+  balanceStepSummaryFromRange,
+  balanceSummary,
   blockPayloadsFromHydratedBlock,
   buildTransaction,
+  calculateFramesFromRange,
   crackOperation,
   crackOperations,
+  deepCalculateFramesFromRange,
   flattenHydratedBlock,
   flattenHydratedBlocks,
   flattenHydratedTransaction,
   flattenHydratedTransactions,
+  hashFromBlockNumber,
   hydrateBlock,
   hydrateElevatedTransaction,
   hydrateTransaction,
-  stepHashFramesFromBlock,
-  stepHashFramesFromBlockAtSize,
+  isNegativeBigInt,
+  isPositiveBigInt,
+  netBalancesForPayloads,
+  parseSignedBigInt,
+  toPositiveBigInt,
+  toSignedBigInt,
   transactionBlockByteCount,
   transactionBytesRequiredGas,
   transactionElevatedPayloadHashes,