@arkiv-network/sdk 0.8.1-dev.1 → 0.9.0-next.2

package/dist/{expiry-Cgdb_dbq.js → expirationTime-UKPuA-LM.js}

@@ -1,25 +1,6 @@
 import { n as InvalidExpiryError } from "./errors-D2E1GRjw.js";
+import { i as BLOCK_TIME, t as MAX_EXPIRES_AT } from "./params-DDJOnsNi.js";
 
-//#region src/consts.ts
-const ARKIV_ADDRESS = "0x4400000000000000000000000000000000000044";
-const BLOCK_TIME = 2;
-
-//#endregion
-//#region src/entity/params.ts
-/**
-* Max uint64 value
-*/
-const MAX_EXPIRES_AT = 2n ** 64n - 1n;
-/** The operation tags of the `execute` ABI's tagged union. */
-const OperationType = {
-	Create: 1,
-	Patch: 2,
-	ExtendExpiry: 3,
-	TransferOwnership: 4,
-	Delete: 5
-};
-
-//#endregion
 //#region src/entity/expiry.ts
 /**
 * Builds a branded {@link Expiry}.
@@ -36,17 +17,19 @@ function makeExpiry(minLifetime, expiresAt) {
 /**
 * Resolves an expiry into the wire pair and the block the entity will expire at.
 *
-* Durations are converted to blocks at the nominal `BLOCK_TIME` (2 seconds), which makes them
-* **approximate**: block production is not a clock, so a lifetime asked for in days drifts if the
-* chain runs fast or slow. The block it was converted to comes back as
-* {@link ResolvedExpiry.target}, so the approximation is always observable rather than assumed.
+* A duration arrives here already in blocks — {@link ExpirationTime} converted it at the nominal
+* `BLOCK_TIME` (2 seconds) through {@link toBlocks} — and a `Date` deadline is placed against
+* `currentBlock` at that same block time here. Both are **approximate**: block production is not a
+* clock, so a lifetime asked for in days drifts if the chain runs fast or slow. The block the
+* expiry resolves to against `currentBlock` comes back as {@link ResolvedExpiry.target}, so the
+* approximation is always observable rather than assumed.
 *
 * @throws {InvalidExpiryError} If the expiry is malformed, does not fit the `uint64` the wire
 * carries, or would leave the entity dead on arrival.
 */
 function resolveExpiry(expiry, context) {
 	const { currentBlock } = context;
-	if (typeof expiry?.minLifetime !== "bigint" || expiry.expiresAt === void 0) throw new InvalidExpiryError("expires must be built with ExpirationTime, e.g. ExpirationTime.fromDays(30) or ExpirationTime.atBlock(1_200_000n)");
+	if (typeof expiry?.minLifetime !== "bigint" || expiry.expiresAt === void 0) throw new InvalidExpiryError("expiration must be built with ExpirationTime, e.g. ExpirationTime.fromDays(30) or ExpirationTime.atBlock(1_200_000n)");
 	const { minLifetime } = expiry;
 	const absolute = typeof expiry.expiresAt === "bigint" ? expiry.expiresAt : blockAtDate(expiry.expiresAt, currentBlock);
 	if (minLifetime === 0n && absolute === 0n) throw new InvalidExpiryError("no expiry given. Pass ExpirationTime.fromDays(30) for a lifetime, ExpirationTime.atBlock(n) for an absolute deadline, or a deadline with { atLeast } to take whichever is later.");
@@ -91,5 +74,57 @@ function blockAtDate(date, currentBlock) {
 }
 
 //#endregion
-export { OperationType as a, MAX_EXPIRES_AT as i, resolveExpiry as n, ARKIV_ADDRESS as o, toBlocks as r, BLOCK_TIME as s, makeExpiry as t };
-//# sourceMappingURL=expiry-Cgdb_dbq.js.map
+//#region src/utils/expirationTime.ts
+function lifetimeOf(seconds) {
+	return makeExpiry(toBlocks(seconds), 0n);
+}
+function deadlineOf(expiresAt, options) {
+	return makeExpiry(options?.atLeast?.minLifetime ?? 0n, expiresAt);
+}
+/**
+* Builds the `expiration` of a create or an extension.
+*
+* Every helper returns the `{ minLifetime, expiresAt }` pair the ABI carries, so what you write is
+* what goes on the wire. The `from*` helpers fill `minLifetime` and leave `expiresAt` at `0n`;
+* {@link ExpirationTime.atBlock} and {@link ExpirationTime.atDate} do the reverse. The engine takes
+* whichever comes later, which is why a deadline can also carry a floor.
+*
+* Values are plain data — no methods, no prototype — so they log, clone and compare like any other
+* object.
+*
+* @example The 90% case: a duration, and nothing else to think about.
+* await client.createEntity(Posts, values, { expiration: ExpirationTime.fromDays(30) })
+*
+* @example An exact block, or a wall-clock date.
+* expiration: ExpirationTime.atBlock(1_200_000n)
+* expiration: ExpirationTime.atDate(new Date("2027-01-01"))
+*
+* @example A deadline that still guarantees a minimum life.
+* expiration: ExpirationTime.atBlock(1_200_000n, { atLeast: ExpirationTime.fromDays(1) })
+*/
+const ExpirationTime = {
+	fromSeconds: (seconds) => lifetimeOf(seconds),
+	fromMinutes: (minutes) => lifetimeOf(minutes * 60),
+	fromHours: (hours) => lifetimeOf(hours * 60 * 60),
+	fromDays: (days) => lifetimeOf(days * 24 * 60 * 60),
+	fromWeeks: (weeks) => lifetimeOf(weeks * 7 * 24 * 60 * 60),
+	fromMonths: (months) => lifetimeOf(months * 30 * 24 * 60 * 60),
+	fromYears: (years) => lifetimeOf(years * 365 * 24 * 60 * 60),
+	fromBlocks: (blocks) => {
+		if (!Number.isInteger(blocks) || blocks <= 0) throw new InvalidExpiryError(`a lifetime must be a positive whole number of blocks, got ${blocks}`);
+		return makeExpiry(BigInt(blocks), 0n);
+	},
+	atBlock: (block, options) => {
+		if (typeof block !== "bigint" || block < 0n) throw new InvalidExpiryError(`a deadline must be a non-negative block height, got ${block}`);
+		return deadlineOf(block, options);
+	},
+	atDate: (date, options) => {
+		if (!(date instanceof Date) || Number.isNaN(date.getTime())) throw new InvalidExpiryError(`a deadline must be a valid Date, got ${String(date)}`);
+		return deadlineOf(date, options);
+	},
+	permanent: () => deadlineOf(MAX_EXPIRES_AT)
+};
+
+//#endregion
+export { resolveExpiry as n, ExpirationTime as t };
+//# sourceMappingURL=expirationTime-UKPuA-LM.js.map

package/dist/expirationTime-UKPuA-LM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expirationTime-UKPuA-LM.js","names":[],"sources":["../src/entity/expiry.ts","../src/utils/expirationTime.ts"],"sourcesContent":["import { BLOCK_TIME } from \"../consts\"\nimport type { ExpirationTime } from \"../utils/expirationTime\"\nimport { InvalidExpiryError } from \"./errors\"\nimport { MAX_EXPIRES_AT } from \"./params\"\n\n/**\n * The brand. Module-private and never exported, so the only way to obtain an {@link Expiry} is to\n * build one with {@link ExpirationTime} — a hand-written `{ minLifetime, expiresAt }` literal will\n * not typecheck, and neither will a bare number of seconds.\n */\ndeclare const validated: unique symbol\n\n/**\n * How long an entity should live.\n *\n * This is the pair the ABI carries, and the engine resolves it as\n * `max(expiresAt, currentBlock + minLifetime)` — whichever is later. Build one with\n * {@link ExpirationTime}; there is no other way to make one.\n *\n * Which slot a value lands in also decides which rules govern it. `minLifetime` is a duration, so\n * it must come to a whole number of blocks. `expiresAt` is a block height, which is a whole number\n * by construction, so a wall-clock date rounds into it rather than being rejected.\n */\nexport type Expiry = {\n  /** Lifetime floor in blocks, counted from the block the transaction lands in. `0n` if unset. */\n  readonly minLifetime: bigint\n  /**\n   * Absolute deadline: a block height, or a `Date` still to be placed against the current block.\n   * `0n` if unset.\n   */\n  readonly expiresAt: bigint | Date\n  readonly [validated]: true\n}\n\n/**\n * An expiry that is nothing but a duration — what the `ExpirationTime.from*` helpers return.\n *\n * Distinguished from a full {@link Expiry} by its `expiresAt` being the literal `0n`, which is what\n * keeps `atBlock(x, { atLeast: atBlock(y) })` from compiling: a deadline is not a floor.\n */\nexport type Lifetime = Expiry & { readonly expiresAt: 0n }\n\n/**\n * Builds a branded {@link Expiry}.\n *\n * Internal seam for {@link ExpirationTime}, which is the only thing that should call it — it is not\n * part of the package's public surface.\n */\nexport function makeExpiry(minLifetime: bigint, expiresAt: bigint | Date): Expiry {\n  return { minLifetime, expiresAt } as Expiry\n}\n\n/** The two `uint64` values the ABI carries, with every `Date` already placed. */\nexport type EncodedExpiry = {\n  /** Absolute target block height, or `0n` for a purely relative lifetime. */\n  expiresAt: bigint\n  /** Relative floor in blocks, or `0n` for a purely absolute expiry. */\n  minLifetime: bigint\n}\n\n/** What an expiry resolves to, given the chain's current block. */\nexport type ResolvedExpiry = EncodedExpiry & {\n  /** The block the entity will expire at — `max(expiresAt, currentBlock + minLifetime)`. */\n  target: bigint\n}\n\n/** What the SDK needs to know about the chain to resolve an expiry. */\nexport type ExpiryContext = {\n  currentBlock: bigint\n}\n\n/**\n * Resolves an expiry into the wire pair and the block the entity will expire at.\n *\n * A duration arrives here already in blocks — {@link ExpirationTime} converted it at the nominal\n * `BLOCK_TIME` (2 seconds) through {@link toBlocks} — and a `Date` deadline is placed against\n * `currentBlock` at that same block time here. Both are **approximate**: block production is not a\n * clock, so a lifetime asked for in days drifts if the chain runs fast or slow. The block the\n * expiry resolves to against `currentBlock` comes back as {@link ResolvedExpiry.target}, so the\n * approximation is always observable rather than assumed.\n *\n * @throws {InvalidExpiryError} If the expiry is malformed, does not fit the `uint64` the wire\n * carries, or would leave the entity dead on arrival.\n */\nexport function resolveExpiry(expiry: Expiry, context: ExpiryContext): ResolvedExpiry {\n  const { currentBlock } = context\n\n  if (typeof expiry?.minLifetime !== \"bigint\" || expiry.expiresAt === undefined) {\n    throw new InvalidExpiryError(\n      \"expiration must be built with ExpirationTime, e.g. ExpirationTime.fromDays(30) or \" +\n        \"ExpirationTime.atBlock(1_200_000n)\",\n    )\n  }\n\n  const { minLifetime } = expiry\n  const absolute =\n    typeof expiry.expiresAt === \"bigint\"\n      ? expiry.expiresAt\n      : blockAtDate(expiry.expiresAt, currentBlock)\n\n  if (minLifetime === 0n && absolute === 0n) {\n    throw new InvalidExpiryError(\n      \"no expiry given. Pass ExpirationTime.fromDays(30) for a lifetime, \" +\n        \"ExpirationTime.atBlock(n) for an absolute deadline, or a deadline with \" +\n        \"{ atLeast } to take whichever is later.\",\n    )\n  }\n\n  if (absolute > MAX_EXPIRES_AT) {\n    throw new InvalidExpiryError(\n      `expiresAt resolves to block ${absolute}, which does not fit the uint64 the wire carries ` +\n        `(max ${MAX_EXPIRES_AT}). Use ExpirationTime.permanent() for an entity that should not ` +\n        \"expire.\",\n    )\n  }\n  if (minLifetime > MAX_EXPIRES_AT) {\n    throw new InvalidExpiryError(\n      `the lifetime is ${minLifetime} blocks, which does not fit the uint64 the wire carries ` +\n        `(max ${MAX_EXPIRES_AT})`,\n    )\n  }\n\n  const relative = minLifetime === 0n ? 0n : currentBlock + minLifetime\n  const target = absolute > relative ? absolute : relative\n\n  if (target <= currentBlock) {\n    throw new InvalidExpiryError(\n      `the entity would expire at block ${target}, which is not after the current block ` +\n        `${currentBlock}, so it would be dead on arrival`,\n    )\n  }\n  if (target > MAX_EXPIRES_AT) {\n    throw new InvalidExpiryError(\n      `a lifetime of ${minLifetime} blocks from block ${currentBlock} lands at ${target}, past ` +\n        `the largest expiry the wire carries (${MAX_EXPIRES_AT})`,\n    )\n  }\n\n  return { expiresAt: absolute, minLifetime, target }\n}\n\n/**\n * A duration in seconds as a whole number of blocks.\n *\n * Arkiv counts lifetimes in blocks, so a duration that is not a whole number of them does not\n * describe anything the chain can store. Rather than silently round a caller's `3` up to two blocks\n * — four seconds, not what they asked for — this rejects it: a duration must be a positive multiple\n * of `BLOCK_TIME` (2 seconds). The {@link ExpirationTime} helpers all produce such multiples.\n *\n * @throws {InvalidExpiryError} If the duration is not a positive whole number of blocks' seconds.\n */\nexport function toBlocks(seconds: number): bigint {\n  if (!Number.isInteger(seconds) || seconds <= 0) {\n    throw new InvalidExpiryError(\n      `a lifetime must be a positive whole number of seconds, got ${seconds}. Use the ` +\n        \"ExpirationTime helpers, e.g. ExpirationTime.fromDays(30).\",\n    )\n  }\n  if (seconds % BLOCK_TIME !== 0) {\n    throw new InvalidExpiryError(\n      `a lifetime must be a multiple of the ${BLOCK_TIME}s block time, got ${seconds}, which is ` +\n        `${seconds / BLOCK_TIME} blocks. Try ${seconds - (seconds % BLOCK_TIME)} or ` +\n        `${seconds + BLOCK_TIME - (seconds % BLOCK_TIME)}, or ExpirationTime.fromBlocks(n).`,\n    )\n  }\n  return BigInt(seconds / BLOCK_TIME)\n}\n\n/**\n * The block a wall-clock instant lands on.\n *\n * Rounds **up**: a date almost never falls on a block boundary, and unlike a duration — which the\n * caller states and can state exactly — there is nothing here to reject, so the entity lives until\n * at least the instant asked for.\n */\nfunction blockAtDate(date: Date, currentBlock: bigint): bigint {\n  const secondsAway = (date.getTime() - Date.now()) / 1000\n  if (secondsAway <= 0) {\n    throw new InvalidExpiryError(\n      `the deadline ${date.toISOString()} is in the past, so the entity would be dead on arrival`,\n    )\n  }\n  return currentBlock + BigInt(Math.ceil(secondsAway / BLOCK_TIME))\n}\n","import { InvalidExpiryError } from \"../entity/errors\"\nimport { type Expiry, type Lifetime, makeExpiry, toBlocks } from \"../entity/expiry\"\nimport { MAX_EXPIRES_AT } from \"../entity/params\"\n\n/**\n * The optional floor a deadline can carry.\n *\n * `atLeast` takes a duration — one of the `from*` helpers — and never another deadline, so\n * `atBlock(x, { atLeast: atBlock(y) })` does not compile. Two deadlines are not a thing the engine\n * can resolve.\n */\nexport type DeadlineOptions = {\n  /** Live at least this long from now, even if the deadline is sooner. */\n  atLeast?: Lifetime | undefined\n}\n\nfunction lifetimeOf(seconds: number): Lifetime {\n  return makeExpiry(toBlocks(seconds), 0n) as Lifetime\n}\n\nfunction deadlineOf(expiresAt: bigint | Date, options?: DeadlineOptions): Expiry {\n  return makeExpiry(options?.atLeast?.minLifetime ?? 0n, expiresAt)\n}\n\n/**\n * Builds the `expiration` of a create or an extension.\n *\n * Every helper returns the `{ minLifetime, expiresAt }` pair the ABI carries, so what you write is\n * what goes on the wire. The `from*` helpers fill `minLifetime` and leave `expiresAt` at `0n`;\n * {@link ExpirationTime.atBlock} and {@link ExpirationTime.atDate} do the reverse. The engine takes\n * whichever comes later, which is why a deadline can also carry a floor.\n *\n * Values are plain data — no methods, no prototype — so they log, clone and compare like any other\n * object.\n *\n * @example The 90% case: a duration, and nothing else to think about.\n * await client.createEntity(Posts, values, { expiration: ExpirationTime.fromDays(30) })\n *\n * @example An exact block, or a wall-clock date.\n * expiration: ExpirationTime.atBlock(1_200_000n)\n * expiration: ExpirationTime.atDate(new Date(\"2027-01-01\"))\n *\n * @example A deadline that still guarantees a minimum life.\n * expiration: ExpirationTime.atBlock(1_200_000n, { atLeast: ExpirationTime.fromDays(1) })\n */\nexport const ExpirationTime = {\n  /**\n   * A raw number of seconds. Must be a whole number of blocks' worth — see the other helpers, which\n   * all produce one by construction.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromSeconds: (seconds: number): Lifetime => lifetimeOf(seconds),\n  /**\n   * A number of minutes.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromMinutes: (minutes: number): Lifetime => lifetimeOf(minutes * 60),\n\n  /**\n   * A number of hours.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromHours: (hours: number): Lifetime => lifetimeOf(hours * 60 * 60),\n\n  /**\n   * A number of days. The everyday form — `fromDays(30)` is what most creates want.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromDays: (days: number): Lifetime => lifetimeOf(days * 24 * 60 * 60),\n\n  /**\n   * A number of weeks, each of 7 days.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromWeeks: (weeks: number): Lifetime => lifetimeOf(weeks * 7 * 24 * 60 * 60),\n\n  /**\n   * A number of months, each of exactly **30 days** — calendar months are not all the same length,\n   * and a lifetime is a duration rather than a date. Use {@link ExpirationTime.atDate} when the\n   * expiry has to land on a particular calendar day.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromMonths: (months: number): Lifetime => lifetimeOf(months * 30 * 24 * 60 * 60),\n\n  /**\n   * A number of years, each of exactly **365 days** — leap days are not counted, so `fromYears(4)`\n   * is a day short of four calendar years. Use {@link ExpirationTime.atDate} for a calendar\n   * deadline.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromYears: (years: number): Lifetime => lifetimeOf(years * 365 * 24 * 60 * 60),\n\n  /**\n   * A number of blocks, for callers who think in the chain's own unit. Always exact — there is no\n   * conversion to be approximate about.\n   *\n   * @throws {InvalidExpiryError} If the count is not a positive whole number.\n   */\n  fromBlocks: (blocks: number): Lifetime => {\n    if (!Number.isInteger(blocks) || blocks <= 0) {\n      throw new InvalidExpiryError(\n        `a lifetime must be a positive whole number of blocks, got ${blocks}`,\n      )\n    }\n    return makeExpiry(BigInt(blocks), 0n) as Lifetime\n  },\n\n  /**\n   * An absolute block height.\n   *\n   * @param block - The block the entity expires at.\n   * @param options - Optionally, a floor: `{ atLeast: ExpirationTime.fromDays(1) }`.\n   * @throws {InvalidExpiryError} If the height is negative.\n   */\n  atBlock: (block: bigint, options?: DeadlineOptions): Expiry => {\n    if (typeof block !== \"bigint\" || block < 0n) {\n      throw new InvalidExpiryError(`a deadline must be a non-negative block height, got ${block}`)\n    }\n    return deadlineOf(block, options)\n  },\n\n  /**\n   * A wall-clock instant, placed against the block the transaction is built on.\n   *\n   * A date cannot land on a block boundary in general, so it rounds **up** to the next block: the\n   * entity lives until at least the instant asked for. This is why a date is never rejected for\n   * \"not being a whole number of blocks\" the way a duration is — it becomes a block height, not a\n   * duration.\n   *\n   * @param date - When the entity should expire.\n   * @param options - Optionally, a floor: `{ atLeast: ExpirationTime.fromDays(1) }`.\n   * @throws {InvalidExpiryError} If the value is not a valid `Date`.\n   */\n  atDate: (date: Date, options?: DeadlineOptions): Expiry => {\n    if (!(date instanceof Date) || Number.isNaN(date.getTime())) {\n      throw new InvalidExpiryError(`a deadline must be a valid Date, got ${String(date)}`)\n    }\n    return deadlineOf(date, options)\n  },\n\n  /**\n   * An entity that should never expire.\n   *\n   * This is `atBlock(MAX_EXPIRES_AT)` — the largest expiry the `uint64` field holds — and the\n   * engine treats it as an ordinary deadline rather than a special case. There is no permanence\n   * flag; a block height no chain will reach is what permanence is.\n   */\n  permanent: (): Expiry => deadlineOf(MAX_EXPIRES_AT),\n}\n"],"mappings":"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"}

package/dist/expiry-B48I-yTA.d.cts

@@ -0,0 +1,40 @@
+//#region src/entity/expiry.d.ts
+/**
+ * The brand. Module-private and never exported, so the only way to obtain an {@link Expiry} is to
+ * build one with {@link ExpirationTime} — a hand-written `{ minLifetime, expiresAt }` literal will
+ * not typecheck, and neither will a bare number of seconds.
+ */
+declare const validated: unique symbol;
+/**
+ * How long an entity should live.
+ *
+ * This is the pair the ABI carries, and the engine resolves it as
+ * `max(expiresAt, currentBlock + minLifetime)` — whichever is later. Build one with
+ * {@link ExpirationTime}; there is no other way to make one.
+ *
+ * Which slot a value lands in also decides which rules govern it. `minLifetime` is a duration, so
+ * it must come to a whole number of blocks. `expiresAt` is a block height, which is a whole number
+ * by construction, so a wall-clock date rounds into it rather than being rejected.
+ */
+type Expiry = {
+  /** Lifetime floor in blocks, counted from the block the transaction lands in. `0n` if unset. */
+  readonly minLifetime: bigint;
+  /**
+   * Absolute deadline: a block height, or a `Date` still to be placed against the current block.
+   * `0n` if unset.
+   */
+  readonly expiresAt: bigint | Date;
+  readonly [validated]: true;
+};
+/**
+ * An expiry that is nothing but a duration — what the `ExpirationTime.from*` helpers return.
+ *
+ * Distinguished from a full {@link Expiry} by its `expiresAt` being the literal `0n`, which is what
+ * keeps `atBlock(x, { atLeast: atBlock(y) })` from compiling: a deadline is not a floor.
+ */
+type Lifetime = Expiry & {
+  readonly expiresAt: 0n;
+};
+//#endregion
+export { Lifetime as n, Expiry as t };
+//# sourceMappingURL=expiry-B48I-yTA.d.cts.map

package/dist/expiry-B48I-yTA.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiry-B48I-yTA.d.cts","names":[],"sources":["../src/entity/expiry.ts"],"sourcesContent":[],"mappings":";;;AAuBA;AAiBA;;cA9Bc;;;;;;;;;;;;KAaF,MAAA;;;;;;;+BAOmB;YACnB,SAAA;;;;;;;;KASA,QAAA,GAAW"}

package/dist/expiry-S2PUL8Hg.d.ts

@@ -0,0 +1,40 @@
+//#region src/entity/expiry.d.ts
+/**
+ * The brand. Module-private and never exported, so the only way to obtain an {@link Expiry} is to
+ * build one with {@link ExpirationTime} — a hand-written `{ minLifetime, expiresAt }` literal will
+ * not typecheck, and neither will a bare number of seconds.
+ */
+declare const validated: unique symbol;
+/**
+ * How long an entity should live.
+ *
+ * This is the pair the ABI carries, and the engine resolves it as
+ * `max(expiresAt, currentBlock + minLifetime)` — whichever is later. Build one with
+ * {@link ExpirationTime}; there is no other way to make one.
+ *
+ * Which slot a value lands in also decides which rules govern it. `minLifetime` is a duration, so
+ * it must come to a whole number of blocks. `expiresAt` is a block height, which is a whole number
+ * by construction, so a wall-clock date rounds into it rather than being rejected.
+ */
+type Expiry = {
+  /** Lifetime floor in blocks, counted from the block the transaction lands in. `0n` if unset. */
+  readonly minLifetime: bigint;
+  /**
+   * Absolute deadline: a block height, or a `Date` still to be placed against the current block.
+   * `0n` if unset.
+   */
+  readonly expiresAt: bigint | Date;
+  readonly [validated]: true;
+};
+/**
+ * An expiry that is nothing but a duration — what the `ExpirationTime.from*` helpers return.
+ *
+ * Distinguished from a full {@link Expiry} by its `expiresAt` being the literal `0n`, which is what
+ * keeps `atBlock(x, { atLeast: atBlock(y) })` from compiling: a deadline is not a floor.
+ */
+type Lifetime = Expiry & {
+  readonly expiresAt: 0n;
+};
+//#endregion
+export { Lifetime as n, Expiry as t };
+//# sourceMappingURL=expiry-S2PUL8Hg.d.ts.map

package/dist/expiry-S2PUL8Hg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiry-S2PUL8Hg.d.ts","names":[],"sources":["../src/entity/expiry.ts"],"sourcesContent":[],"mappings":";;;AAuBA;AAiBA;;cA9Bc;;;;;;;;;;;;KAaF,MAAA;;;;;;;+BAOmB;YACnB,SAAA;;;;;;;;KASA,QAAA,GAAW"}