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

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

@@ -85,6 +85,15 @@ export declare const ConfigZod: z.ZodObject<{
         }>, {
             readonly __address: true;
         }>, unknown>>>>>;
+        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, {
+            readonly __address: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, {
+            readonly __address: true;
+        }>, unknown>>>>>;
     }, z.core.$strip>>;
     logLevel: z.ZodDefault<z.ZodEnum<{
         error: "error";

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;AAcxB,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAAmF,CAAA;AAErH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYpB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,eAAO,MAAM,gBAAgB,QAAO,MAA6B,CAAA"}
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../src/config/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAcxB,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAAmF,CAAA;AAErH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYpB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,eAAO,MAAM,gBAAgB,QAAO,MAA6B,CAAA"}

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

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

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

@@ -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;;;;;;;;;;iBAY9B,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.d.ts

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

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

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

package/dist/neutral/index.mjs

@@ -772,18 +772,18 @@ var RewardRedemptionApiConfigZod = z9.object({
   host: z9.string().default("localhost").register(globalRegistry8, {
     default: "localhost",
     description: "Host for the Redemption API",
-    title: "redemption.host",
+    title: "rewardRedemptionApi.host",
     type: "string"
   }),
   mnemonic: MnemonicStringZod.optional().register(globalRegistry8, {
     description: "Mnemonic for the Redemption API wallet",
-    title: "redemption.mnemonic",
+    title: "rewardRedemptionApi.mnemonic",
     type: "string"
   }),
   port: z9.coerce.number().default(8082).register(globalRegistry8, {
     default: 8082,
     description: "Port for the Redemption API",
-    title: "redemption.port",
+    title: "rewardRedemptionApi.port",
     type: "number"
   })
 });
@@ -867,6 +867,16 @@ var ValidationConfigZod = z13.object({
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
+  })),
+  allowedRewardEscrowAccountSigners: z13.preprocess((val) => {
+    if (typeof val === "string") {
+      return val.split(",").map((s) => asAddress4(s.trim()));
+    }
+    return val;
+  }, z13.array(AddressZod2).optional().register(globalRegistry12, {
+    description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
+    title: "allowedRewardEscrowAccountSigners",
+    type: "array"
   }))
 });
 
@@ -949,8 +959,87 @@ var RewardMultipliers = {
   ]
 };
 
-// src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
+// src/primitives/step/completedStepRewardAddress.ts
+import { toAddress as toAddress2 } from "@xylabs/hex";
+import { keccak256 } from "ethers";
+function completedStepRewardAddress({ block, step }) {
+  const addressKey = new TextEncoder().encode(`${block}|${step}`);
+  return toAddress2(keccak256(addressKey).slice(-40), {
+    prefix: false
+  });
+}
+__name(completedStepRewardAddress, "completedStepRewardAddress");
+
+// src/primitives/step/derivedReceiveAddress.ts
+import { toAddress as toAddress3 } from "@xylabs/hex";
+import { isDefined as isDefined5 } from "@xylabs/typeof";
+import { keccak256 as keccak2562 } from "ethers";
+function derivedReceiveAddress(address, scope) {
+  const addressKey = new TextEncoder().encode(isDefined5(scope) ? `${scope}|${address}` : address);
+  return toAddress3(keccak2562(addressKey).slice(-40), {
+    prefix: false
+  });
+}
+__name(derivedReceiveAddress, "derivedReceiveAddress");
+
+// src/primitives/step/stepBlockRange.ts
+import { asXL1BlockRange, StepSizes as StepSizes5 } from "@xyo-network/xl1-protocol";
+function stepBlockRange({ block, step }) {
+  const stepSize2 = StepSizes5[step];
+  const start = block - stepSize2;
+  return asXL1BlockRange([
+    start,
+    start + stepSize2 - 1
+  ]);
+}
+__name(stepBlockRange, "stepBlockRange");
+
+// src/primitives/step/stepTransferIndex.ts
 import { assertEx as assertEx6 } from "@xylabs/assert";
+import { StepSizes as StepSizes6 } from "@xyo-network/xl1-protocol";
+function stepTransferIndex(block, step) {
+  let rewardTransferCount = 0;
+  let rewardTransferIndex = -1;
+  for (let i = 3; i < StepSizes6.length; i++) {
+    const stepSize2 = StepSizes6[i];
+    if (block % stepSize2 === 0) {
+      if (stepSize2 === StepSizes6[step]) {
+        rewardTransferIndex = rewardTransferCount;
+      }
+      rewardTransferCount++;
+    }
+  }
+  assertEx6(rewardTransferIndex >= 0, () => `Error: Could not find step size for step ${step} at block ${block}`);
+  return [
+    rewardTransferIndex,
+    rewardTransferCount
+  ];
+}
+__name(stepTransferIndex, "stepTransferIndex");
+
+// src/primitives/transaction/elevatedPayloads.ts
+import { isAllowedBlockPayload } from "@xyo-network/xl1-protocol";
+function elevatedPayloads([tx, payloads]) {
+  const opCodes = (tx.script ?? []).filter((operation) => operation.startsWith("elevate|"));
+  const elevatedPayloads2 = [];
+  for (const opCode of opCodes) {
+    const [code, hash] = opCode.split("|");
+    if (code === "elevated") {
+      const elevatedPayload = payloads.find((payload) => payload._hash === hash);
+      if (isAllowedBlockPayload(elevatedPayload)) {
+        elevatedPayloads2.push(elevatedPayload);
+      }
+    }
+  }
+  if (opCodes.length === elevatedPayloads2.length) {
+    return elevatedPayloads2;
+  }
+  throw new Error("Not all elevated payloads could be found in the transaction payloads");
+}
+__name(elevatedPayloads, "elevatedPayloads");
+
+// src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
+import { assertEx as assertEx7 } from "@xylabs/assert";
 import { asTimePayload, TimeSchema } from "@xyo-network/xl1-protocol";
 async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
@@ -958,12 +1047,12 @@ async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const timePayload = asTimePayload(hydratedBlock[1].find((p) => p.schema === TimeSchema), {
     required: true
   });
-  return assertEx6(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx7(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 __name(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
 
 // src/transaction/buildTransaction.ts
-import { assertEx as assertEx7 } from "@xylabs/assert";
+import { assertEx as assertEx8 } from "@xylabs/assert";
 import { toHex as toHex2 } from "@xylabs/hex";
 import { BoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
 import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
@@ -990,7 +1079,7 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
   }
   const fields = {
     ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx7(signer.at(0)?.address) : signer.address)
+    from: from ?? (Array.isArray(signer) ? assertEx8(signer.at(0)?.address) : signer.address)
   };
   if (script.length > 0) {
     fields.script = script;
@@ -1054,7 +1143,7 @@ __name(buildUnsignedTransaction, "buildUnsignedTransaction");
 
 // src/transaction/confirmSubmittedTransaction.ts
 import { delay } from "@xylabs/delay";
-import { isDefined as isDefined5 } from "@xylabs/typeof";
+import { isDefined as isDefined6 } from "@xylabs/typeof";
 import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
@@ -1065,7 +1154,7 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transact
   let attempts = 0;
   while (true) {
     const tx = await viewer.transactionByHash(txBWHash) ?? void 0;
-    if (isDefined5(tx)) {
+    if (isDefined6(tx)) {
       options?.logger?.log("\u2705 Transaction confirmed:", txBWHash, "\n");
       return tx;
     } else {
@@ -1082,9 +1171,9 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transact
 }, "confirmSubmittedTransaction");
 
 // src/transaction/hydrateTransaction.ts
-import { assertEx as assertEx8 } from "@xylabs/assert";
+import { assertEx as assertEx9 } from "@xylabs/assert";
 import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from "@xyo-network/archivist-model";
-import { isAllowedBlockPayload, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { isAllowedBlockPayload as isAllowedBlockPayload2, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var tryHydrateTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
   return await tryHydrateTypedBoundWitness({
     get(hashes) {
@@ -1122,26 +1211,26 @@ var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async ({ chainMap },
   }
   const [transaction, payloads] = hydratedTransaction;
   const opCodes = (transaction.script ?? []).filter((operation) => operation.startsWith("elevate|"));
-  const elevatedPayloads = [];
+  const elevatedPayloads2 = [];
   for (const opCode of opCodes) {
     const [code, hash2] = opCode.split("|");
     if (code === "elevated") {
       const elevatedPayload = payloads.find((payload) => payload._hash === hash2);
-      if (isAllowedBlockPayload(elevatedPayload)) {
-        elevatedPayloads.push(elevatedPayload);
+      if (isAllowedBlockPayload2(elevatedPayload)) {
+        elevatedPayloads2.push(elevatedPayload);
       }
     }
   }
-  if (opCodes.length === elevatedPayloads.length) {
+  if (opCodes.length === elevatedPayloads2.length) {
     return [
       transaction,
-      elevatedPayloads
+      elevatedPayloads2
     ];
   }
   return void 0;
 }, "tryHydrateElevatedTransaction");
 var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (context, hash) => {
-  return assertEx8(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
+  return assertEx9(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
 }, "hydrateElevatedTransaction");
 
 // src/transaction/primitives/transactionBlockByteCount.ts
@@ -1182,8 +1271,8 @@ function transactionElevatedPayloadHashes(transaction) {
 __name(transactionElevatedPayloadHashes, "transactionElevatedPayloadHashes");
 function transactionElevatedPayloads([transaction, payloads]) {
   const hashes = transactionElevatedPayloadHashes(transaction);
-  const elevatedPayloads = payloads.filter((payload) => hashes.includes(payload._hash));
-  return elevatedPayloads;
+  const elevatedPayloads2 = payloads.filter((payload) => hashes.includes(payload._hash));
+  return elevatedPayloads2;
 }
 __name(transactionElevatedPayloads, "transactionElevatedPayloads");
 
@@ -1198,16 +1287,16 @@ function transactionBytesRequiredGas([transaction, payloads]) {
 }
 __name(transactionBytesRequiredGas, "transactionBytesRequiredGas");
 function transactionRequiredGas(hydratedTransaction) {
-  const elevatedPayloads = transactionElevatedPayloads(hydratedTransaction);
-  const hashes = elevatedPayloads.length + 1;
+  const elevatedPayloads2 = transactionElevatedPayloads(hydratedTransaction);
+  const hashes = elevatedPayloads2.length + 1;
   const signatures = hydratedTransaction[0].addresses.length;
-  return AttoXL1(transactionBytesRequiredGas(hydratedTransaction) + TransactionGasCosts.hashValidation * BigInt(hashes) + TransactionGasCosts.signatureValidation * BigInt(signatures) + TransactionGasCosts.payloadValidation * BigInt(elevatedPayloads.length));
+  return AttoXL1(transactionBytesRequiredGas(hydratedTransaction) + TransactionGasCosts.hashValidation * BigInt(hashes) + TransactionGasCosts.signatureValidation * BigInt(signatures) + TransactionGasCosts.payloadValidation * BigInt(elevatedPayloads2.length));
 }
 __name(transactionRequiredGas, "transactionRequiredGas");
 
 // src/transaction/script.ts
 import { filterAs as filterAs2 } from "@xylabs/array";
-import { assertEx as assertEx9 } from "@xylabs/assert";
+import { assertEx as assertEx10 } from "@xylabs/assert";
 import { asHash as asHash3 } from "@xylabs/hex";
 import { isAllowedBlockPayloadWithHashStorageMeta } from "@xyo-network/xl1-protocol";
 var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
@@ -1217,7 +1306,7 @@ var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
 var extractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
   const filtered = filterAs2(hashes, (h) => asHash3(h));
-  assertEx9(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx10(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashesFromScript");
 var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
@@ -1231,17 +1320,17 @@ var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
   const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashStorageMeta);
-  assertEx9(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx10(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashes");
 
 // src/transaction/signTransaction.ts
 import { toArrayBuffer } from "@xylabs/arraybuffer";
-import { assertEx as assertEx10 } from "@xylabs/assert";
+import { assertEx as assertEx11 } from "@xylabs/assert";
 import { hexFromArrayBuffer } from "@xylabs/hex";
 import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 async function signTransaction(tx, account) {
-  assertEx10(tx.from === account.address, () => "Signer address does not match transaction from address");
+  assertEx11(tx.from === account.address, () => "Signer address does not match transaction from address");
   const signedTx = structuredClone(tx);
   signedTx.addresses = [
     account.address
@@ -1322,10 +1411,13 @@ export {
   buildTransaction,
   buildUnsignedTransaction,
   calculateFramesFromRange,
+  completedStepRewardAddress,
   confirmSubmittedTransaction,
   crackOperation,
   crackOperations,
   deepCalculateFramesFromRange,
+  derivedReceiveAddress,
+  elevatedPayloads,
   extractElevatedHashes,
   extractElevatedHashesFromScript,
   flattenHydratedBlock,
@@ -1354,6 +1446,8 @@ export {
   parseSignedBigInt,
   readPayloadMapFromStore,
   signTransaction,
+  stepBlockRange,
+  stepTransferIndex,
   toPositiveBigInt,
   toSignedBigInt,
   transactionBlockByteCount,