@umbra-privacy/sdk 1.0.0

package/dist/chunk-MDFSBU5W.cjs

@@ -0,0 +1,2033 @@
+'use strict';
+
+var chunkPK6SKIKE_cjs = require('./chunk-PK6SKIKE.cjs');
+
+// src/common/types.ts
+var U8_MAX = 0xffn;
+var U16_MAX = 0xffffn;
+var U32_MAX = 0xffffffffn;
+var U64_MAX = 0xffffffffffffffffn;
+var U128_MAX = (1n << 128n) - 1n;
+var U256_MAX = (1n << 256n) - 1n;
+var U512_MAX = (1n << 512n) - 1n;
+var U1024_MAX = (1n << 1024n) - 1n;
+var I8_MIN = -(1n << 7n);
+var I8_MAX = (1n << 7n) - 1n;
+var I16_MIN = -(1n << 15n);
+var I16_MAX = (1n << 15n) - 1n;
+var I32_MIN = -(1n << 31n);
+var I32_MAX = (1n << 31n) - 1n;
+var I64_MIN = -(1n << 63n);
+var I64_MAX = (1n << 63n) - 1n;
+var I128_MIN = -(1n << 127n);
+var I128_MAX = (1n << 127n) - 1n;
+var I256_MIN = -(1n << 255n);
+var I256_MAX = (1n << 255n) - 1n;
+var I512_MIN = -(1n << 511n);
+var I512_MAX = (1n << 511n) - 1n;
+var I1024_MIN = -(1n << 1023n);
+var I1024_MAX = (1n << 1023n) - 1n;
+var U8_BYTE_LENGTH = 1;
+var U16_BYTE_LENGTH = 2;
+var U32_BYTE_LENGTH = 4;
+var U64_BYTE_LENGTH = 8;
+var U128_BYTE_LENGTH = 16;
+var U256_BYTE_LENGTH = 32;
+var U512_BYTE_LENGTH = 64;
+var U1024_BYTE_LENGTH = 128;
+var MathematicsAssertionError = class _MathematicsAssertionError extends Error {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "MathematicsAssertionError");
+  }
+  /**
+   * The actual value that failed the assertion.
+   *
+   * @remarks
+   * This can be any type depending on what was being asserted.
+   * For integer assertions, this will be a `bigint`.
+   * For byte array assertions, this will be a `Uint8Array`.
+   *
+   * @readonly
+   */
+  value;
+  /**
+   * The type that was expected.
+   *
+   * @remarks
+   * This is the branded type name (e.g., "U8", "U256", "U32LeBytes").
+   *
+   * @readonly
+   */
+  expectedType;
+  /**
+   * Description of the constraint that was violated.
+   *
+   * @remarks
+   * This is `undefined` if only a type check failed (e.g., expected bigint, got string).
+   * It contains a human-readable constraint description when a value is out of range.
+   *
+   * @example
+   * - "0 <= value <= 255" for U8 range violations
+   * - "length === 32" for U256LeBytes length violations
+   * - "value >= 0" for negative unsigned integer attempts
+   *
+   * @readonly
+   */
+  constraint;
+  /**
+   * Creates a new MathematicsAssertionError.
+   *
+   * @param message - Human-readable error message
+   * @param options - Error details
+   * @param options.value - The value that failed assertion
+   * @param options.expectedType - The expected type name
+   * @param options.constraint - Optional constraint description
+   */
+  constructor(message, options) {
+    super(message);
+    this.name = "MathematicsAssertionError";
+    this.value = options.value;
+    this.expectedType = options.expectedType;
+    this.constraint = options.constraint;
+    Error.captureStackTrace(this, _MathematicsAssertionError);
+    Object.setPrototypeOf(this, _MathematicsAssertionError.prototype);
+  }
+};
+function assertBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "Bytes"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertBytes, "assertBytes");
+function assertLeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "LeBytes"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertLeBytes, "assertLeBytes");
+function assertBeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "BeBytes"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertBeBytes, "assertBeBytes");
+function assertU8LeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U8LeBytes"
+    });
+  }
+  if (value.length !== U8_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U8_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U8LeBytes",
+        constraint: `length === ${String(U8_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU8LeBytes, "assertU8LeBytes");
+function assertU16LeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U16LeBytes"
+    });
+  }
+  if (value.length !== U16_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U16_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U16LeBytes",
+        constraint: `length === ${String(U16_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU16LeBytes, "assertU16LeBytes");
+function assertU32LeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U32LeBytes"
+    });
+  }
+  if (value.length !== U32_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U32_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U32LeBytes",
+        constraint: `length === ${String(U32_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU32LeBytes, "assertU32LeBytes");
+function assertU64LeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U64LeBytes"
+    });
+  }
+  if (value.length !== U64_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U64_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U64LeBytes",
+        constraint: `length === ${String(U64_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU64LeBytes, "assertU64LeBytes");
+function assertU128LeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U128LeBytes"
+    });
+  }
+  if (value.length !== U128_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U128_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U128LeBytes",
+        constraint: `length === ${String(U128_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU128LeBytes, "assertU128LeBytes");
+function assertU256LeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U256LeBytes"
+    });
+  }
+  if (value.length !== U256_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U256_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U256LeBytes",
+        constraint: `length === ${String(U256_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU256LeBytes, "assertU256LeBytes");
+function assertU512LeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U512LeBytes"
+    });
+  }
+  if (value.length !== U512_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U512_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U512LeBytes",
+        constraint: `length === ${String(U512_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU512LeBytes, "assertU512LeBytes");
+function assertU1024LeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U1024LeBytes"
+    });
+  }
+  if (value.length !== U1024_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U1024_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U1024LeBytes",
+        constraint: `length === ${String(U1024_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU1024LeBytes, "assertU1024LeBytes");
+function assertU8BeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U8BeBytes"
+    });
+  }
+  if (value.length !== U8_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U8_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U8BeBytes",
+        constraint: `length === ${String(U8_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU8BeBytes, "assertU8BeBytes");
+function assertU16BeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U16BeBytes"
+    });
+  }
+  if (value.length !== U16_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U16_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U16BeBytes",
+        constraint: `length === ${String(U16_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU16BeBytes, "assertU16BeBytes");
+function assertU32BeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U32BeBytes"
+    });
+  }
+  if (value.length !== U32_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U32_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U32BeBytes",
+        constraint: `length === ${String(U32_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU32BeBytes, "assertU32BeBytes");
+function assertU64BeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U64BeBytes"
+    });
+  }
+  if (value.length !== U64_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U64_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U64BeBytes",
+        constraint: `length === ${String(U64_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU64BeBytes, "assertU64BeBytes");
+function assertU128BeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U128BeBytes"
+    });
+  }
+  if (value.length !== U128_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U128_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U128BeBytes",
+        constraint: `length === ${String(U128_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU128BeBytes, "assertU128BeBytes");
+function assertU256BeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U256BeBytes"
+    });
+  }
+  if (value.length !== U256_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U256_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U256BeBytes",
+        constraint: `length === ${String(U256_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU256BeBytes, "assertU256BeBytes");
+function assertU512BeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U512BeBytes"
+    });
+  }
+  if (value.length !== U512_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U512_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U512BeBytes",
+        constraint: `length === ${String(U512_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU512BeBytes, "assertU512BeBytes");
+function assertU1024BeBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new MathematicsAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "U1024BeBytes"
+    });
+  }
+  if (value.length !== U1024_BYTE_LENGTH) {
+    throw new MathematicsAssertionError(
+      `Expected ${String(U1024_BYTE_LENGTH)} byte(s), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "U1024BeBytes",
+        constraint: `length === ${String(U1024_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU1024BeBytes, "assertU1024BeBytes");
+function assertUnsignedInteger(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "UnsignedInteger"
+    });
+  }
+  if (value < 0n) {
+    throw new MathematicsAssertionError(`Expected non-negative value, got ${String(value)}`, {
+      value,
+      expectedType: "UnsignedInteger",
+      constraint: "value >= 0"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertUnsignedInteger, "assertUnsignedInteger");
+function assertSignedInteger(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "SignedInteger"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertSignedInteger, "assertSignedInteger");
+function assertU8(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "U8"
+    });
+  }
+  if (value < 0n || value > U8_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for U8 [0, ${String(U8_MAX)}]`,
+      {
+        value,
+        expectedType: "U8",
+        constraint: `0 <= value <= ${String(U8_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU8, "assertU8");
+function assertU16(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "U16"
+    });
+  }
+  if (value < 0n || value > U16_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for U16 [0, ${String(U16_MAX)}]`,
+      {
+        value,
+        expectedType: "U16",
+        constraint: `0 <= value <= ${String(U16_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU16, "assertU16");
+function assertU32(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "U32"
+    });
+  }
+  if (value < 0n || value > U32_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for U32 [0, ${String(U32_MAX)}]`,
+      {
+        value,
+        expectedType: "U32",
+        constraint: `0 <= value <= ${String(U32_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU32, "assertU32");
+function assertU64(value, name = "value") {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`${name}: Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "U64"
+    });
+  }
+  if (value < 0n || value > U64_MAX) {
+    throw new MathematicsAssertionError(
+      `${name}: Value ${String(value)} is out of range for U64 [0, ${String(U64_MAX)}]`,
+      {
+        value,
+        expectedType: "U64",
+        constraint: `0 <= value <= ${String(U64_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU64, "assertU64");
+function assertU128(value, name = "value") {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`${name}: Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "U128"
+    });
+  }
+  if (value < 0n || value > U128_MAX) {
+    throw new MathematicsAssertionError(
+      `${name}: Value ${String(value)} is out of range for U128 [0, 2^128 - 1]`,
+      {
+        value,
+        expectedType: "U128",
+        constraint: "0 <= value <= 2^128 - 1"
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU128, "assertU128");
+function assertU256(value, name = "value") {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`${name}: Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "U256"
+    });
+  }
+  if (value < 0n || value > U256_MAX) {
+    throw new MathematicsAssertionError(
+      `${name}: Value ${String(value)} is out of range for U256 [0, 2^256 - 1]`,
+      {
+        value,
+        expectedType: "U256",
+        constraint: "0 <= value <= 2^256 - 1"
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU256, "assertU256");
+function assertU512(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "U512"
+    });
+  }
+  if (value < 0n || value > U512_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for U512 [0, 2^512 - 1]`,
+      {
+        value,
+        expectedType: "U512",
+        constraint: "0 <= value <= 2^512 - 1"
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU512, "assertU512");
+function assertU1024(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "U1024"
+    });
+  }
+  if (value < 0n || value > U1024_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for U1024 [0, 2^1024 - 1]`,
+      {
+        value,
+        expectedType: "U1024",
+        constraint: "0 <= value <= 2^1024 - 1"
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertU1024, "assertU1024");
+function assertI8(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "I8"
+    });
+  }
+  if (value < I8_MIN || value > I8_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for I8 [${String(I8_MIN)}, ${String(I8_MAX)}]`,
+      {
+        value,
+        expectedType: "I8",
+        constraint: `${String(I8_MIN)} <= value <= ${String(I8_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertI8, "assertI8");
+function assertI16(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "I16"
+    });
+  }
+  if (value < I16_MIN || value > I16_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for I16 [${String(I16_MIN)}, ${String(I16_MAX)}]`,
+      {
+        value,
+        expectedType: "I16",
+        constraint: `${String(I16_MIN)} <= value <= ${String(I16_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertI16, "assertI16");
+function assertI32(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "I32"
+    });
+  }
+  if (value < I32_MIN || value > I32_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for I32 [${String(I32_MIN)}, ${String(I32_MAX)}]`,
+      {
+        value,
+        expectedType: "I32",
+        constraint: `${String(I32_MIN)} <= value <= ${String(I32_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertI32, "assertI32");
+function assertI64(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "I64"
+    });
+  }
+  if (value < I64_MIN || value > I64_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for I64 [-2^63, 2^63 - 1]`,
+      {
+        value,
+        expectedType: "I64",
+        constraint: "-2^63 <= value <= 2^63 - 1"
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertI64, "assertI64");
+function assertI128(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "I128"
+    });
+  }
+  if (value < I128_MIN || value > I128_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for I128 [-2^127, 2^127 - 1]`,
+      {
+        value,
+        expectedType: "I128",
+        constraint: "-2^127 <= value <= 2^127 - 1"
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertI128, "assertI128");
+function assertI256(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "I256"
+    });
+  }
+  if (value < I256_MIN || value > I256_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for I256 [-2^255, 2^255 - 1]`,
+      {
+        value,
+        expectedType: "I256",
+        constraint: "-2^255 <= value <= 2^255 - 1"
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertI256, "assertI256");
+function assertI512(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "I512"
+    });
+  }
+  if (value < I512_MIN || value > I512_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for I512 [-2^511, 2^511 - 1]`,
+      {
+        value,
+        expectedType: "I512",
+        constraint: "-2^511 <= value <= 2^511 - 1"
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertI512, "assertI512");
+function assertI1024(value) {
+  if (typeof value !== "bigint") {
+    throw new MathematicsAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "I1024"
+    });
+  }
+  if (value < I1024_MIN || value > I1024_MAX) {
+    throw new MathematicsAssertionError(
+      `Value ${String(value)} is out of range for I1024 [-2^1023, 2^1023 - 1]`,
+      {
+        value,
+        expectedType: "I1024",
+        constraint: "-2^1023 <= value <= 2^1023 - 1"
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertI1024, "assertI1024");
+
+// src/types/cryptography.ts
+var BN254_FIELD_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+var CURVE25519_FIELD_PRIME = (1n << 255n) - 19n;
+var CryptographyAssertionError = class _CryptographyAssertionError extends Error {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "CryptographyAssertionError");
+  }
+  /**
+   * The actual value that failed the assertion.
+   * @readonly
+   */
+  value;
+  /**
+   * The type that was expected (e.g., "Bn254FieldElement", "PoseidonKey").
+   * @readonly
+   */
+  expectedType;
+  /**
+   * Description of the constraint that was violated.
+   *
+   * @remarks
+   * Will be `undefined` when the failure is purely a type mismatch (e.g., received a string
+   * instead of a bigint). Contains a human-readable range or length constraint when the value
+   * was the correct type but out of the valid range.
+   *
+   * @example `"value >= 0"`, `"value < BN254_FIELD_PRIME"`, `"length === 32"`
+   * @readonly
+   */
+  constraint;
+  /**
+   * Creates a new CryptographyAssertionError.
+   *
+   * @param message - Human-readable error message describing what went wrong
+   * @param options - Structured error details for programmatic inspection
+   * @param options.value - The value that failed the assertion
+   * @param options.expectedType - Name of the branded type that was expected
+   * @param options.constraint - Optional human-readable constraint that was violated
+   */
+  constructor(message, options) {
+    super(message);
+    this.name = "CryptographyAssertionError";
+    this.value = options.value;
+    this.expectedType = options.expectedType;
+    this.constraint = options.constraint;
+    Error.captureStackTrace(this, _CryptographyAssertionError);
+    Object.setPrototypeOf(this, _CryptographyAssertionError.prototype);
+  }
+};
+var X25519_BYTE_LENGTH = 32;
+function assertBn254FieldElement(value, name = "value") {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`${name}: Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "Bn254FieldElement"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`${name}: Value ${String(value)} is negative`, {
+      value,
+      expectedType: "Bn254FieldElement",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`${name}: Value exceeds BN254 field prime`, {
+      value,
+      expectedType: "Bn254FieldElement",
+      constraint: `value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertBn254FieldElement, "assertBn254FieldElement");
+function assertCurve25519FieldElement(value, name = "value") {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`${name}: Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "Curve25519FieldElement"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`${name}: Value ${String(value)} is negative`, {
+      value,
+      expectedType: "Curve25519FieldElement",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= CURVE25519_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`${name}: Value exceeds Curve25519 field prime`, {
+      value,
+      expectedType: "Curve25519FieldElement",
+      constraint: "value < 2^255 - 19"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertCurve25519FieldElement, "assertCurve25519FieldElement");
+function assertX25519Bytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "X25519Bytes"
+    });
+  }
+  if (value.length !== X25519_BYTE_LENGTH) {
+    throw new CryptographyAssertionError(
+      `Expected ${String(X25519_BYTE_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "X25519Bytes",
+        constraint: `length === ${String(X25519_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertX25519Bytes, "assertX25519Bytes");
+function assertX25519PrivateKey(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "X25519PrivateKey"
+    });
+  }
+  if (value.length !== X25519_BYTE_LENGTH) {
+    throw new CryptographyAssertionError(
+      `Expected ${String(X25519_BYTE_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "X25519PrivateKey",
+        constraint: `length === ${String(X25519_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertX25519PrivateKey, "assertX25519PrivateKey");
+function assertX25519PublicKey(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "X25519PublicKey"
+    });
+  }
+  if (value.length !== X25519_BYTE_LENGTH) {
+    throw new CryptographyAssertionError(
+      `Expected ${String(X25519_BYTE_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "X25519PublicKey",
+        constraint: `length === ${String(X25519_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertX25519PublicKey, "assertX25519PublicKey");
+function assertSharedSecret(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "SharedSecret"
+    });
+  }
+  if (value.length !== X25519_BYTE_LENGTH) {
+    throw new CryptographyAssertionError(
+      `Expected ${String(X25519_BYTE_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "SharedSecret",
+        constraint: `length === ${String(X25519_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertSharedSecret, "assertSharedSecret");
+function assertPoseidonPlaintext(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "PoseidonPlaintext"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`Value ${String(value)} is negative`, {
+      value,
+      expectedType: "PoseidonPlaintext",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value exceeds BN254 field prime`, {
+      value,
+      expectedType: "PoseidonPlaintext",
+      constraint: `value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertPoseidonPlaintext, "assertPoseidonPlaintext");
+function assertPoseidonHash(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "PoseidonHash"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`Value ${String(value)} is negative`, {
+      value,
+      expectedType: "PoseidonHash",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value exceeds BN254 field prime`, {
+      value,
+      expectedType: "PoseidonHash",
+      constraint: `value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertPoseidonHash, "assertPoseidonHash");
+function assertPoseidonKey(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "PoseidonKey"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`Value ${String(value)} is negative`, {
+      value,
+      expectedType: "PoseidonKey",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value exceeds BN254 field prime`, {
+      value,
+      expectedType: "PoseidonKey",
+      constraint: `value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertPoseidonKey, "assertPoseidonKey");
+function assertPoseidonCiphertext(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "PoseidonCiphertext"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`Value ${String(value)} is negative`, {
+      value,
+      expectedType: "PoseidonCiphertext",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value exceeds BN254 field prime`, {
+      value,
+      expectedType: "PoseidonCiphertext",
+      constraint: `value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertPoseidonCiphertext, "assertPoseidonCiphertext");
+function assertPoseidonCounter(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "PoseidonCounter"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`Value ${String(value)} is negative`, {
+      value,
+      expectedType: "PoseidonCounter",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value exceeds BN254 field prime`, {
+      value,
+      expectedType: "PoseidonCounter",
+      constraint: `value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertPoseidonCounter, "assertPoseidonCounter");
+function assertPoseidonKeystream(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "PoseidonKeystream"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`Value ${String(value)} is negative`, {
+      value,
+      expectedType: "PoseidonKeystream",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value exceeds BN254 field prime`, {
+      value,
+      expectedType: "PoseidonKeystream",
+      constraint: `value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertPoseidonKeystream, "assertPoseidonKeystream");
+function assertRcCiphertext(value, name = "value") {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`${name}: Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "RcCiphertext"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`${name}: Value ${String(value)} is negative`, {
+      value,
+      expectedType: "RcCiphertext",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= CURVE25519_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`${name}: Value exceeds Curve25519 field prime`, {
+      value,
+      expectedType: "RcCiphertext",
+      constraint: "value < 2^255 - 19"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertRcCiphertext, "assertRcCiphertext");
+function assertRcPlaintext(value, name = "value") {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`${name}: Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "RcPlaintext"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`${name}: Value ${String(value)} is negative`, {
+      value,
+      expectedType: "RcPlaintext",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= CURVE25519_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`${name}: Value exceeds Curve25519 field prime`, {
+      value,
+      expectedType: "RcPlaintext",
+      constraint: "value < 2^255 - 19"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertRcPlaintext, "assertRcPlaintext");
+function assertRcKey(value, name = "value") {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`${name}: Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "RcKey"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`${name}: Value ${String(value)} is negative`, {
+      value,
+      expectedType: "RcKey",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= CURVE25519_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`${name}: Value exceeds Curve25519 field prime`, {
+      value,
+      expectedType: "RcKey",
+      constraint: "value < 2^255 - 19"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertRcKey, "assertRcKey");
+function assertRcCounter(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "RcCounter"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`Value ${String(value)} is negative`, {
+      value,
+      expectedType: "RcCounter",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= CURVE25519_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value exceeds Curve25519 field prime`, {
+      value,
+      expectedType: "RcCounter",
+      constraint: "value < 2^255 - 19"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertRcCounter, "assertRcCounter");
+function assertRcEncryptionNonce(value, name = "value") {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`${name}: Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "RcEncryptionNonce"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`${name}: Value ${String(value)} is negative`, {
+      value,
+      expectedType: "RcEncryptionNonce",
+      constraint: "value >= 0"
+    });
+  }
+  if (value > U128_MAX) {
+    throw new CryptographyAssertionError(`${name}: Value exceeds U128 maximum`, {
+      value,
+      expectedType: "RcEncryptionNonce",
+      constraint: "value <= 2^128 - 1"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertRcEncryptionNonce, "assertRcEncryptionNonce");
+function assertKeccak256Hash(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "Keccak256Hash"
+    });
+  }
+  if (value.length !== U256_BYTE_LENGTH) {
+    throw new CryptographyAssertionError(
+      `Expected ${String(U256_BYTE_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "Keccak256Hash",
+        constraint: `length === ${String(U256_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertKeccak256Hash, "assertKeccak256Hash");
+function assertKeccak512Hash(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "Keccak512Hash"
+    });
+  }
+  if (value.length !== U512_BYTE_LENGTH) {
+    throw new CryptographyAssertionError(
+      `Expected ${String(U512_BYTE_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "Keccak512Hash",
+        constraint: `length === ${String(U512_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertKeccak512Hash, "assertKeccak512Hash");
+function assertMasterSeed(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "MasterSeed"
+    });
+  }
+  if (value.length !== U512_BYTE_LENGTH) {
+    throw new CryptographyAssertionError(
+      `Expected ${String(U512_BYTE_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "MasterSeed",
+        constraint: `length === ${String(U512_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertMasterSeed, "assertMasterSeed");
+function assertGenerationSeed(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "GenerationSeed"
+    });
+  }
+  if (value.length !== U512_BYTE_LENGTH) {
+    throw new CryptographyAssertionError(
+      `Expected ${String(U512_BYTE_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "GenerationSeed",
+        constraint: `length === ${String(U512_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertGenerationSeed, "assertGenerationSeed");
+function assertMasterViewingKey(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "MasterViewingKey"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`Value ${String(value)} is negative`, {
+      value,
+      expectedType: "MasterViewingKey",
+      constraint: "value >= 0"
+    });
+  }
+  if (value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value exceeds BN254 field prime`, {
+      value,
+      expectedType: "MasterViewingKey",
+      constraint: `value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertMasterViewingKey, "assertMasterViewingKey");
+function assertYearlyViewingKey(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "YearlyViewingKey"
+    });
+  }
+  if (value < 0n || value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value out of BN254 field range`, {
+      value,
+      expectedType: "YearlyViewingKey",
+      constraint: `0 <= value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertYearlyViewingKey, "assertYearlyViewingKey");
+function assertMonthlyViewingKey(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "MonthlyViewingKey"
+    });
+  }
+  if (value < 0n || value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value out of BN254 field range`, {
+      value,
+      expectedType: "MonthlyViewingKey",
+      constraint: `0 <= value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertMonthlyViewingKey, "assertMonthlyViewingKey");
+function assertDailyViewingKey(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "DailyViewingKey"
+    });
+  }
+  if (value < 0n || value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value out of BN254 field range`, {
+      value,
+      expectedType: "DailyViewingKey",
+      constraint: `0 <= value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertDailyViewingKey, "assertDailyViewingKey");
+function assertHourlyViewingKey(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "HourlyViewingKey"
+    });
+  }
+  if (value < 0n || value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value out of BN254 field range`, {
+      value,
+      expectedType: "HourlyViewingKey",
+      constraint: `0 <= value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertHourlyViewingKey, "assertHourlyViewingKey");
+function assertMinuteViewingKey(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "MinuteViewingKey"
+    });
+  }
+  if (value < 0n || value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value out of BN254 field range`, {
+      value,
+      expectedType: "MinuteViewingKey",
+      constraint: `0 <= value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertMinuteViewingKey, "assertMinuteViewingKey");
+function assertSecondViewingKey(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "SecondViewingKey"
+    });
+  }
+  if (value < 0n || value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value out of BN254 field range`, {
+      value,
+      expectedType: "SecondViewingKey",
+      constraint: `0 <= value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertSecondViewingKey, "assertSecondViewingKey");
+function assertMintViewingKey(value) {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "MintViewingKey"
+    });
+  }
+  if (value < 0n || value >= BN254_FIELD_PRIME) {
+    throw new CryptographyAssertionError(`Value out of BN254 field range`, {
+      value,
+      expectedType: "MintViewingKey",
+      constraint: `0 <= value < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertMintViewingKey, "assertMintViewingKey");
+function assertX25519Keypair(value) {
+  if (!("privateKey" in value) || !("publicKey" in value)) {
+    throw new CryptographyAssertionError(
+      `Expected object with privateKey and publicKey properties`,
+      {
+        value,
+        expectedType: "X25519Keypair",
+        constraint: "must have privateKey and publicKey"
+      }
+    );
+  }
+  assertX25519PrivateKey(value.privateKey);
+  assertX25519PublicKey(value.publicKey);
+}
+chunkPK6SKIKE_cjs.__name(assertX25519Keypair, "assertX25519Keypair");
+var BASE85_LIMB_MAX = (1n << 85n) - 1n;
+function assertBase85Limb(value, name = "value") {
+  if (typeof value !== "bigint") {
+    throw new CryptographyAssertionError(`${name}: Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "Base85Limb"
+    });
+  }
+  if (value < 0n) {
+    throw new CryptographyAssertionError(`${name}: Value ${String(value)} is negative`, {
+      value,
+      expectedType: "Base85Limb",
+      constraint: "value >= 0"
+    });
+  }
+  if (value > BASE85_LIMB_MAX) {
+    throw new CryptographyAssertionError(`${name}: Value exceeds Base85 limb maximum`, {
+      value,
+      expectedType: "Base85Limb",
+      constraint: `value <= 2^85 - 1`
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertBase85Limb, "assertBase85Limb");
+var GROTH16_G1_BYTE_LENGTH = 64;
+var GROTH16_G2_BYTE_LENGTH = 128;
+function assertGroth16ProofA(value, name) {
+  if (!(value instanceof Uint8Array)) {
+    throw new TypeError(`${name ?? "value"} must be a Uint8Array, got ${typeof value}`);
+  }
+  if (value.length !== GROTH16_G1_BYTE_LENGTH) {
+    throw new TypeError(
+      `${name ?? "Groth16ProofA"} must be exactly ${String(GROTH16_G1_BYTE_LENGTH)} bytes, got ${String(value.length)}`
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertGroth16ProofA, "assertGroth16ProofA");
+function assertGroth16ProofB(value, name) {
+  if (!(value instanceof Uint8Array)) {
+    throw new TypeError(`${name ?? "value"} must be a Uint8Array, got ${typeof value}`);
+  }
+  if (value.length !== GROTH16_G2_BYTE_LENGTH) {
+    throw new TypeError(
+      `${name ?? "Groth16ProofB"} must be exactly ${String(GROTH16_G2_BYTE_LENGTH)} bytes, got ${String(value.length)}`
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertGroth16ProofB, "assertGroth16ProofB");
+function assertGroth16ProofC(value, name) {
+  if (!(value instanceof Uint8Array)) {
+    throw new TypeError(`${name ?? "value"} must be a Uint8Array, got ${typeof value}`);
+  }
+  if (value.length !== GROTH16_G1_BYTE_LENGTH) {
+    throw new TypeError(
+      `${name ?? "Groth16ProofC"} must be exactly ${String(GROTH16_G1_BYTE_LENGTH)} bytes, got ${String(value.length)}`
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertGroth16ProofC, "assertGroth16ProofC");
+var ZK_PROOF_BYTE_LENGTH = 256;
+function assertZkProofBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "ZkProofBytes"
+    });
+  }
+  if (value.length !== ZK_PROOF_BYTE_LENGTH) {
+    throw new CryptographyAssertionError(
+      `Expected ${String(ZK_PROOF_BYTE_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "ZkProofBytes",
+        constraint: `length === ${String(ZK_PROOF_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertZkProofBytes, "assertZkProofBytes");
+var AES_KEY_LENGTH = 32;
+var AES_IV_LENGTH = 12;
+var AES_AUTH_TAG_LENGTH = 16;
+var AES_METADATA_OVERHEAD = AES_IV_LENGTH + AES_AUTH_TAG_LENGTH;
+function assertAesKey(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "AesKey"
+    });
+  }
+  if (value.length !== AES_KEY_LENGTH) {
+    throw new CryptographyAssertionError(
+      `Expected ${String(AES_KEY_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "AesKey",
+        constraint: `length === ${String(AES_KEY_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertAesKey, "assertAesKey");
+function assertAesPlaintext(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "AesPlaintext"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertAesPlaintext, "assertAesPlaintext");
+function assertAesCiphertextWithMetadata(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "AesCiphertextWithMetadata"
+    });
+  }
+  if (value.length < AES_METADATA_OVERHEAD) {
+    throw new CryptographyAssertionError(
+      `Expected at least ${String(AES_METADATA_OVERHEAD)} bytes (IV + AuthTag), got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "AesCiphertextWithMetadata",
+        constraint: `length >= ${String(AES_METADATA_OVERHEAD)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertAesCiphertextWithMetadata, "assertAesCiphertextWithMetadata");
+var OPTIONAL_DATA_BYTE_LENGTH = 32;
+function assertOptionalData32(value, name) {
+  if (!(value instanceof Uint8Array)) {
+    throw new CryptographyAssertionError(
+      `${name ?? "OptionalData32"}: Expected Uint8Array, got ${typeof value}`,
+      {
+        value,
+        expectedType: "OptionalData32"
+      }
+    );
+  }
+  if (value.length !== OPTIONAL_DATA_BYTE_LENGTH) {
+    throw new CryptographyAssertionError(
+      `${name ?? "OptionalData32"} must be exactly ${String(OPTIONAL_DATA_BYTE_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "OptionalData32",
+        constraint: `length === ${String(OPTIONAL_DATA_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertOptionalData32, "assertOptionalData32");
+
+// src/solana/types.ts
+var SIGNATURE_BYTE_LENGTH = 64;
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var BASE58_REGEX = /^[1-9A-HJ-NP-Za-km-z]+$/;
+var SolanaAssertionError = class _SolanaAssertionError extends Error {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "SolanaAssertionError");
+  }
+  /**
+   * The actual value that was passed to the assertion function and failed
+   * the type check.
+   *
+   * @remarks
+   * Typed as `unknown` because assertion functions accept values of unknown
+   * type before narrowing. Inspect carefully — the value may be `undefined`,
+   * `null`, or any primitive or object.
+   */
+  value;
+  /**
+   * The name of the expected type (e.g., `"TransactionSignature"`,
+   * `"SignatureBytes"`).
+   *
+   * @remarks
+   * Matches the TypeScript type name for the intended branded type, not a
+   * JavaScript `typeof` string.
+   */
+  expectedType;
+  /**
+   * A human-readable description of the specific constraint that was violated,
+   * if applicable.
+   *
+   * @remarks
+   * Examples:
+   * - `"length > 0"` — empty string passed to `assertTransactionSignature`
+   * - `"length === 64"` — wrong byte count passed to `assertSignatureBytes`
+   * - `"characters must be in base58 alphabet: 123...xyz"` — invalid character
+   *
+   * `undefined` when the only constraint is the TypeScript type itself
+   * (e.g., `assertString` only checks `typeof value === "string"`).
+   */
+  constraint;
+  /**
+   * Creates a new `SolanaAssertionError`.
+   *
+   * @param message - Human-readable description of the assertion failure.
+   * @param options - Structured context for the failed assertion.
+   * @param options.value - The value that failed the assertion.
+   * @param options.expectedType - The name of the expected branded type.
+   * @param options.constraint - The specific constraint that was violated, if any.
+   */
+  constructor(message, options) {
+    super(message);
+    this.name = "SolanaAssertionError";
+    this.value = options.value;
+    this.expectedType = options.expectedType;
+    this.constraint = options.constraint;
+    Error.captureStackTrace(this, _SolanaAssertionError);
+    Object.setPrototypeOf(this, _SolanaAssertionError.prototype);
+  }
+};
+function assertString(value) {
+  if (typeof value !== "string") {
+    throw new SolanaAssertionError(`Expected string, got ${typeof value}`, {
+      value,
+      expectedType: "String"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertString, "assertString");
+function assertTransactionSignature(value) {
+  if (typeof value !== "string") {
+    throw new SolanaAssertionError(`Expected string, got ${typeof value}`, {
+      value,
+      expectedType: "TransactionSignature"
+    });
+  }
+  if (value.length === 0) {
+    throw new SolanaAssertionError("Transaction signature cannot be empty", {
+      value,
+      expectedType: "TransactionSignature",
+      constraint: "length > 0"
+    });
+  }
+  if (!BASE58_REGEX.test(value)) {
+    let invalidChar = "";
+    let invalidIndex = -1;
+    for (const [index, element] of Array.from(value).entries()) {
+      if (!BASE58_ALPHABET.includes(element)) {
+        invalidChar = element;
+        invalidIndex = index;
+        break;
+      }
+    }
+    throw new SolanaAssertionError(
+      `Invalid base58 character '${invalidChar}' at position ${String(invalidIndex)}`,
+      {
+        value,
+        expectedType: "TransactionSignature",
+        constraint: `characters must be in base58 alphabet: ${BASE58_ALPHABET}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertTransactionSignature, "assertTransactionSignature");
+function assertSolanaBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new SolanaAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "SolanaBytes"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertSolanaBytes, "assertSolanaBytes");
+function assertSignatureBytes(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new SolanaAssertionError(`Expected Uint8Array, got ${typeof value}`, {
+      value,
+      expectedType: "SignatureBytes"
+    });
+  }
+  if (value.length !== SIGNATURE_BYTE_LENGTH) {
+    throw new SolanaAssertionError(
+      `Expected ${String(SIGNATURE_BYTE_LENGTH)} bytes, got ${String(value.length)}`,
+      {
+        value,
+        expectedType: "SignatureBytes",
+        constraint: `length === ${String(SIGNATURE_BYTE_LENGTH)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertSignatureBytes, "assertSignatureBytes");
+function asRelayableSignedTransaction(tx) {
+  return tx;
+}
+chunkPK6SKIKE_cjs.__name(asRelayableSignedTransaction, "asRelayableSignedTransaction");
+
+// src/common/temporal/types.ts
+var YEAR_MIN = 0n;
+var YEAR_MAX = 9999n;
+var MONTH_MIN = 1n;
+var MONTH_MAX = 12n;
+var DAY_MIN = 1n;
+var DAY_MAX = 31n;
+var HOUR_MIN = 0n;
+var HOUR_MAX = 23n;
+var MINUTE_MIN = 0n;
+var MINUTE_MAX = 59n;
+var SECOND_MIN = 0n;
+var SECOND_MAX = 59n;
+var TemporalAssertionError = class extends Error {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "TemporalAssertionError");
+  }
+  /**
+   * The actual value that failed the assertion.
+   * @readonly
+   */
+  value;
+  /**
+   * The type that was expected (e.g., `"Month"`, `"Hour"`).
+   * @readonly
+   */
+  expectedType;
+  /**
+   * Description of the constraint that was violated.
+   *
+   * @remarks
+   * `undefined` when the failure was a type mismatch (e.g., received a number instead of a
+   * bigint). Contains a human-readable range string (e.g., `"1 <= value <= 12"`) when the
+   * value was the correct type but out of the valid range.
+   * @readonly
+   */
+  constraint;
+  /**
+   * Creates a new TemporalAssertionError.
+   *
+   * @param message - Human-readable description of what went wrong
+   * @param details - Structured error details for programmatic inspection
+   * @param details.value - The value that failed the assertion
+   * @param details.expectedType - Name of the branded type that was expected
+   * @param details.constraint - Optional human-readable constraint that was violated
+   */
+  constructor(message, details) {
+    super(message);
+    this.name = "TemporalAssertionError";
+    this.value = details.value;
+    this.expectedType = details.expectedType;
+    this.constraint = details.constraint;
+  }
+};
+function assertTimestampComponent(value) {
+  if (typeof value !== "bigint") {
+    throw new TemporalAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "TimestampComponent"
+    });
+  }
+  if (value < 0n) {
+    throw new TemporalAssertionError(`TimestampComponent must be non-negative`, {
+      value,
+      expectedType: "TimestampComponent",
+      constraint: "value >= 0"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertTimestampComponent, "assertTimestampComponent");
+function assertYear(value) {
+  if (typeof value !== "bigint") {
+    throw new TemporalAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "Year"
+    });
+  }
+  if (value < YEAR_MIN || value > YEAR_MAX) {
+    throw new TemporalAssertionError(
+      `Year must be in range [${String(YEAR_MIN)}, ${String(YEAR_MAX)}]`,
+      {
+        value,
+        expectedType: "Year",
+        constraint: `${String(YEAR_MIN)} <= value <= ${String(YEAR_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertYear, "assertYear");
+function assertMonth(value) {
+  if (typeof value !== "bigint") {
+    throw new TemporalAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "Month"
+    });
+  }
+  if (value < MONTH_MIN || value > MONTH_MAX) {
+    throw new TemporalAssertionError(
+      `Month must be in range [${String(MONTH_MIN)}, ${String(MONTH_MAX)}]`,
+      {
+        value,
+        expectedType: "Month",
+        constraint: `${String(MONTH_MIN)} <= value <= ${String(MONTH_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertMonth, "assertMonth");
+function assertDay(value) {
+  if (typeof value !== "bigint") {
+    throw new TemporalAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "Day"
+    });
+  }
+  if (value < DAY_MIN || value > DAY_MAX) {
+    throw new TemporalAssertionError(
+      `Day must be in range [${String(DAY_MIN)}, ${String(DAY_MAX)}]`,
+      {
+        value,
+        expectedType: "Day",
+        constraint: `${String(DAY_MIN)} <= value <= ${String(DAY_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertDay, "assertDay");
+function assertHour(value) {
+  if (typeof value !== "bigint") {
+    throw new TemporalAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "Hour"
+    });
+  }
+  if (value < HOUR_MIN || value > HOUR_MAX) {
+    throw new TemporalAssertionError(
+      `Hour must be in range [${String(HOUR_MIN)}, ${String(HOUR_MAX)}]`,
+      {
+        value,
+        expectedType: "Hour",
+        constraint: `${String(HOUR_MIN)} <= value <= ${String(HOUR_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertHour, "assertHour");
+function assertMinute(value) {
+  if (typeof value !== "bigint") {
+    throw new TemporalAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "Minute"
+    });
+  }
+  if (value < MINUTE_MIN || value > MINUTE_MAX) {
+    throw new TemporalAssertionError(
+      `Minute must be in range [${String(MINUTE_MIN)}, ${String(MINUTE_MAX)}]`,
+      {
+        value,
+        expectedType: "Minute",
+        constraint: `${String(MINUTE_MIN)} <= value <= ${String(MINUTE_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertMinute, "assertMinute");
+function assertSecond(value) {
+  if (typeof value !== "bigint") {
+    throw new TemporalAssertionError(`Expected bigint, got ${typeof value}`, {
+      value,
+      expectedType: "Second"
+    });
+  }
+  if (value < SECOND_MIN || value > SECOND_MAX) {
+    throw new TemporalAssertionError(
+      `Second must be in range [${String(SECOND_MIN)}, ${String(SECOND_MAX)}]`,
+      {
+        value,
+        expectedType: "Second",
+        constraint: `${String(SECOND_MIN)} <= value <= ${String(SECOND_MAX)}`
+      }
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertSecond, "assertSecond");
+
+exports.AES_AUTH_TAG_LENGTH = AES_AUTH_TAG_LENGTH;
+exports.AES_IV_LENGTH = AES_IV_LENGTH;
+exports.AES_KEY_LENGTH = AES_KEY_LENGTH;
+exports.AES_METADATA_OVERHEAD = AES_METADATA_OVERHEAD;
+exports.BASE85_LIMB_MAX = BASE85_LIMB_MAX;
+exports.BN254_FIELD_PRIME = BN254_FIELD_PRIME;
+exports.CURVE25519_FIELD_PRIME = CURVE25519_FIELD_PRIME;
+exports.CryptographyAssertionError = CryptographyAssertionError;
+exports.DAY_MAX = DAY_MAX;
+exports.DAY_MIN = DAY_MIN;
+exports.GROTH16_G1_BYTE_LENGTH = GROTH16_G1_BYTE_LENGTH;
+exports.GROTH16_G2_BYTE_LENGTH = GROTH16_G2_BYTE_LENGTH;
+exports.HOUR_MAX = HOUR_MAX;
+exports.HOUR_MIN = HOUR_MIN;
+exports.I1024_MAX = I1024_MAX;
+exports.I1024_MIN = I1024_MIN;
+exports.I128_MAX = I128_MAX;
+exports.I128_MIN = I128_MIN;
+exports.I16_MAX = I16_MAX;
+exports.I16_MIN = I16_MIN;
+exports.I256_MAX = I256_MAX;
+exports.I256_MIN = I256_MIN;
+exports.I32_MAX = I32_MAX;
+exports.I32_MIN = I32_MIN;
+exports.I512_MAX = I512_MAX;
+exports.I512_MIN = I512_MIN;
+exports.I64_MAX = I64_MAX;
+exports.I64_MIN = I64_MIN;
+exports.I8_MAX = I8_MAX;
+exports.I8_MIN = I8_MIN;
+exports.MINUTE_MAX = MINUTE_MAX;
+exports.MINUTE_MIN = MINUTE_MIN;
+exports.MONTH_MAX = MONTH_MAX;
+exports.MONTH_MIN = MONTH_MIN;
+exports.MathematicsAssertionError = MathematicsAssertionError;
+exports.OPTIONAL_DATA_BYTE_LENGTH = OPTIONAL_DATA_BYTE_LENGTH;
+exports.SECOND_MAX = SECOND_MAX;
+exports.SECOND_MIN = SECOND_MIN;
+exports.SIGNATURE_BYTE_LENGTH = SIGNATURE_BYTE_LENGTH;
+exports.SolanaAssertionError = SolanaAssertionError;
+exports.TemporalAssertionError = TemporalAssertionError;
+exports.U1024_BYTE_LENGTH = U1024_BYTE_LENGTH;
+exports.U1024_MAX = U1024_MAX;
+exports.U128_BYTE_LENGTH = U128_BYTE_LENGTH;
+exports.U128_MAX = U128_MAX;
+exports.U16_BYTE_LENGTH = U16_BYTE_LENGTH;
+exports.U16_MAX = U16_MAX;
+exports.U256_BYTE_LENGTH = U256_BYTE_LENGTH;
+exports.U256_MAX = U256_MAX;
+exports.U32_BYTE_LENGTH = U32_BYTE_LENGTH;
+exports.U32_MAX = U32_MAX;
+exports.U512_BYTE_LENGTH = U512_BYTE_LENGTH;
+exports.U512_MAX = U512_MAX;
+exports.U64_BYTE_LENGTH = U64_BYTE_LENGTH;
+exports.U64_MAX = U64_MAX;
+exports.U8_BYTE_LENGTH = U8_BYTE_LENGTH;
+exports.U8_MAX = U8_MAX;
+exports.X25519_BYTE_LENGTH = X25519_BYTE_LENGTH;
+exports.YEAR_MAX = YEAR_MAX;
+exports.YEAR_MIN = YEAR_MIN;
+exports.ZK_PROOF_BYTE_LENGTH = ZK_PROOF_BYTE_LENGTH;
+exports.asRelayableSignedTransaction = asRelayableSignedTransaction;
+exports.assertAesCiphertextWithMetadata = assertAesCiphertextWithMetadata;
+exports.assertAesKey = assertAesKey;
+exports.assertAesPlaintext = assertAesPlaintext;
+exports.assertBase85Limb = assertBase85Limb;
+exports.assertBeBytes = assertBeBytes;
+exports.assertBn254FieldElement = assertBn254FieldElement;
+exports.assertBytes = assertBytes;
+exports.assertCurve25519FieldElement = assertCurve25519FieldElement;
+exports.assertDailyViewingKey = assertDailyViewingKey;
+exports.assertDay = assertDay;
+exports.assertGenerationSeed = assertGenerationSeed;
+exports.assertGroth16ProofA = assertGroth16ProofA;
+exports.assertGroth16ProofB = assertGroth16ProofB;
+exports.assertGroth16ProofC = assertGroth16ProofC;
+exports.assertHour = assertHour;
+exports.assertHourlyViewingKey = assertHourlyViewingKey;
+exports.assertI1024 = assertI1024;
+exports.assertI128 = assertI128;
+exports.assertI16 = assertI16;
+exports.assertI256 = assertI256;
+exports.assertI32 = assertI32;
+exports.assertI512 = assertI512;
+exports.assertI64 = assertI64;
+exports.assertI8 = assertI8;
+exports.assertKeccak256Hash = assertKeccak256Hash;
+exports.assertKeccak512Hash = assertKeccak512Hash;
+exports.assertLeBytes = assertLeBytes;
+exports.assertMasterSeed = assertMasterSeed;
+exports.assertMasterViewingKey = assertMasterViewingKey;
+exports.assertMintViewingKey = assertMintViewingKey;
+exports.assertMinute = assertMinute;
+exports.assertMinuteViewingKey = assertMinuteViewingKey;
+exports.assertMonth = assertMonth;
+exports.assertMonthlyViewingKey = assertMonthlyViewingKey;
+exports.assertOptionalData32 = assertOptionalData32;
+exports.assertPoseidonCiphertext = assertPoseidonCiphertext;
+exports.assertPoseidonCounter = assertPoseidonCounter;
+exports.assertPoseidonHash = assertPoseidonHash;
+exports.assertPoseidonKey = assertPoseidonKey;
+exports.assertPoseidonKeystream = assertPoseidonKeystream;
+exports.assertPoseidonPlaintext = assertPoseidonPlaintext;
+exports.assertRcCiphertext = assertRcCiphertext;
+exports.assertRcCounter = assertRcCounter;
+exports.assertRcEncryptionNonce = assertRcEncryptionNonce;
+exports.assertRcKey = assertRcKey;
+exports.assertRcPlaintext = assertRcPlaintext;
+exports.assertSecond = assertSecond;
+exports.assertSecondViewingKey = assertSecondViewingKey;
+exports.assertSharedSecret = assertSharedSecret;
+exports.assertSignatureBytes = assertSignatureBytes;
+exports.assertSignedInteger = assertSignedInteger;
+exports.assertSolanaBytes = assertSolanaBytes;
+exports.assertString = assertString;
+exports.assertTimestampComponent = assertTimestampComponent;
+exports.assertTransactionSignature = assertTransactionSignature;
+exports.assertU1024 = assertU1024;
+exports.assertU1024BeBytes = assertU1024BeBytes;
+exports.assertU1024LeBytes = assertU1024LeBytes;
+exports.assertU128 = assertU128;
+exports.assertU128BeBytes = assertU128BeBytes;
+exports.assertU128LeBytes = assertU128LeBytes;
+exports.assertU16 = assertU16;
+exports.assertU16BeBytes = assertU16BeBytes;
+exports.assertU16LeBytes = assertU16LeBytes;
+exports.assertU256 = assertU256;
+exports.assertU256BeBytes = assertU256BeBytes;
+exports.assertU256LeBytes = assertU256LeBytes;
+exports.assertU32 = assertU32;
+exports.assertU32BeBytes = assertU32BeBytes;
+exports.assertU32LeBytes = assertU32LeBytes;
+exports.assertU512 = assertU512;
+exports.assertU512BeBytes = assertU512BeBytes;
+exports.assertU512LeBytes = assertU512LeBytes;
+exports.assertU64 = assertU64;
+exports.assertU64BeBytes = assertU64BeBytes;
+exports.assertU64LeBytes = assertU64LeBytes;
+exports.assertU8 = assertU8;
+exports.assertU8BeBytes = assertU8BeBytes;
+exports.assertU8LeBytes = assertU8LeBytes;
+exports.assertUnsignedInteger = assertUnsignedInteger;
+exports.assertX25519Bytes = assertX25519Bytes;
+exports.assertX25519Keypair = assertX25519Keypair;
+exports.assertX25519PrivateKey = assertX25519PrivateKey;
+exports.assertX25519PublicKey = assertX25519PublicKey;
+exports.assertYear = assertYear;
+exports.assertYearlyViewingKey = assertYearlyViewingKey;
+exports.assertZkProofBytes = assertZkProofBytes;
+//# sourceMappingURL=chunk-MDFSBU5W.cjs.map
+//# sourceMappingURL=chunk-MDFSBU5W.cjs.map