@unconfirmed/sui-effect 0.1.0

package/dist/domain/journal-entry.d.ts

@@ -0,0 +1,468 @@
+/**
+ * `JournalEntry`: the transaction lifecycle as a serializable union.
+ *
+ * This is the only place the lifecycle appears as a union; the abstraction a
+ * program uses is the functions in `Tx`. An entry exists so that a process that
+ * dies between signing and the answer can find out, when it comes back, what it
+ * had already put on the wire.
+ *
+ * @since 0.1.0
+ */
+import { Schema } from "effect";
+/**
+ * One line of the submission journal.
+ *
+ * `Signed` is written before the first `executeTransaction` and means the bytes
+ * may be on the wire. `Executed`, `Failed` and `NotApplied` are terminal:
+ * `Executed` and `Failed` because the network answered, `NotApplied` because
+ * the transaction was proven never to have applied and never will. `Unknown`
+ * means the answer never arrived and the bytes are kept so `Tx.reconcile` can
+ * settle it later.
+ *
+ * Without a terminal `NotApplied`, a durable journal would hold a proven-dead
+ * submission as `Unknown` forever and `onUnresolved: "fail"` would refuse to
+ * build for the life of the store.
+ */
+export declare const JournalEntry: Schema.TaggedUnion<{
+    readonly Unknown: Schema.TaggedStruct<"Unknown", {
+        readonly digest: Schema.brand<Schema.String, "Digest">;
+        readonly signed: Schema.Struct<{
+            readonly digest: Schema.brand<Schema.String, "Digest">;
+            readonly bytes: Schema.Uint8ArrayFromBase64;
+            readonly signatures: Schema.$Array<Schema.brand<Schema.String, "Signature">>;
+            readonly sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            readonly expiration: Schema.optional<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+                readonly $kind: Schema.Literal<"None">;
+                readonly None: Schema.Literal<true>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Epoch">;
+                readonly Epoch: Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ValidDuring">;
+                readonly ValidDuring: Schema.Struct<{
+                    readonly minEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly maxEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly minTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly maxTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly chain: Schema.String;
+                    readonly nonce: Schema.Number;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Validity">;
+                readonly Validity: Schema.Struct<{
+                    readonly allowedProposers: Schema.NullOr<Schema.Struct<{
+                        readonly epoch: Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>;
+                        readonly proposers: Schema.$Array<Schema.Number>;
+                    }>>;
+                    readonly minEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly maxEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly minTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly maxTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly chain: Schema.String;
+                    readonly nonce: Schema.Number;
+                }>;
+            }>]>>;
+            readonly chain: Schema.optional<Schema.String>;
+        }>;
+        readonly lastError: Schema.String;
+        readonly attempts: Schema.Number;
+        readonly at: Schema.DateTimeUtcFromMillis;
+    }>;
+    readonly NotApplied: Schema.TaggedStruct<"NotApplied", {
+        readonly digest: Schema.brand<Schema.String, "Digest">;
+        readonly evidence: Schema.Literals<readonly ["expired", "inputConsumed"]>;
+        readonly at: Schema.DateTimeUtcFromMillis;
+    }>;
+    readonly Signed: Schema.TaggedStruct<"Signed", {
+        readonly digest: Schema.brand<Schema.String, "Digest">;
+        readonly signed: Schema.Struct<{
+            readonly digest: Schema.brand<Schema.String, "Digest">;
+            readonly bytes: Schema.Uint8ArrayFromBase64;
+            readonly signatures: Schema.$Array<Schema.brand<Schema.String, "Signature">>;
+            readonly sender: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            readonly expiration: Schema.optional<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+                readonly $kind: Schema.Literal<"None">;
+                readonly None: Schema.Literal<true>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Epoch">;
+                readonly Epoch: Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ValidDuring">;
+                readonly ValidDuring: Schema.Struct<{
+                    readonly minEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly maxEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly minTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly maxTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly chain: Schema.String;
+                    readonly nonce: Schema.Number;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Validity">;
+                readonly Validity: Schema.Struct<{
+                    readonly allowedProposers: Schema.NullOr<Schema.Struct<{
+                        readonly epoch: Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>;
+                        readonly proposers: Schema.$Array<Schema.Number>;
+                    }>>;
+                    readonly minEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly maxEpoch: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly minTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly maxTimestamp: Schema.NullOr<Schema.decodeTo<Schema.BigInt, Schema.Union<readonly [Schema.String, Schema.Number]>, never, never>>;
+                    readonly chain: Schema.String;
+                    readonly nonce: Schema.Number;
+                }>;
+            }>]>>;
+            readonly chain: Schema.optional<Schema.String>;
+        }>;
+        readonly signedAt: Schema.DateTimeUtcFromMillis;
+    }>;
+    readonly Executed: Schema.TaggedStruct<"Executed", {
+        readonly digest: Schema.brand<Schema.String, "Digest">;
+        readonly checkpoint: Schema.optional<Schema.BigIntFromString>;
+        readonly at: Schema.DateTimeUtcFromMillis;
+    }>;
+    readonly Failed: Schema.TaggedStruct<"Failed", {
+        readonly digest: Schema.brand<Schema.String, "Digest">;
+        readonly reason: Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+            readonly $kind: Schema.Literal<"MoveAbort">;
+            readonly MoveAbort: Schema.Struct<{
+                readonly abortCode: Schema.BigIntFromString;
+                readonly location: Schema.optional<Schema.Struct<{
+                    readonly package: Schema.optional<Schema.String>;
+                    readonly module: Schema.optional<Schema.String>;
+                    readonly function: Schema.optional<Schema.Number>;
+                    readonly functionName: Schema.optional<Schema.String>;
+                    readonly instruction: Schema.optional<Schema.Number>;
+                }>>;
+                readonly cleverError: Schema.optional<Schema.Struct<{
+                    readonly errorCode: Schema.optional<Schema.Number>;
+                    readonly lineNumber: Schema.optional<Schema.Number>;
+                    readonly constantName: Schema.optional<Schema.String>;
+                    readonly constantType: Schema.optional<Schema.String>;
+                    readonly value: Schema.optional<Schema.String>;
+                }>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"SizeError">;
+            readonly SizeError: Schema.Struct<{
+                readonly name: Schema.String;
+                readonly size: Schema.Number;
+                readonly maxSize: Schema.Number;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"CommandArgumentError">;
+            readonly CommandArgumentError: Schema.Struct<{
+                readonly argument: Schema.Number;
+                readonly name: Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"TypeArgumentError">;
+            readonly TypeArgumentError: Schema.Struct<{
+                readonly typeArgument: Schema.Number;
+                readonly name: Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"PackageUpgradeError">;
+            readonly PackageUpgradeError: Schema.Struct<{
+                readonly name: Schema.String;
+                readonly packageId: Schema.optional<Schema.String>;
+                readonly digest: Schema.optional<Schema.String>;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"IndexError">;
+            readonly IndexError: Schema.Struct<{
+                readonly index: Schema.optional<Schema.Number>;
+                readonly subresult: Schema.optional<Schema.Number>;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"CoinDenyListError">;
+            readonly CoinDenyListError: Schema.Struct<{
+                readonly name: Schema.String;
+                readonly coinType: Schema.String;
+                readonly address: Schema.optional<Schema.String>;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"CongestedObjects">;
+            readonly CongestedObjects: Schema.Struct<{
+                readonly name: Schema.String;
+                readonly objects: Schema.$Array<Schema.String>;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"ObjectIdError">;
+            readonly ObjectIdError: Schema.Struct<{
+                readonly name: Schema.optional<Schema.String>;
+                readonly objectId: Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            readonly $kind: Schema.Literal<"Unknown">;
+        }>]>;
+        readonly at: Schema.DateTimeUtcFromMillis;
+    }>;
+}>;
+export type JournalEntry = typeof JournalEntry.Type;
+/** The tags whose entries still need an answer from the network. */
+export declare const UNRESOLVED_TAGS: readonly ["Signed", "Unknown"];
+/**
+ * Whether this entry is still waiting for an answer, and therefore something
+ * `Tx.reconcileAll` has work to do about. Never fails.
+ */
+export declare const isUnresolved: (value: {
+    readonly _tag: "Unknown";
+    readonly digest: string & import("effect/Brand").Brand<"Digest">;
+    readonly signed: {
+        readonly digest: string & import("effect/Brand").Brand<"Digest">;
+        readonly sender: string & import("effect/Brand").Brand<"SuiAddress">;
+        readonly signatures: readonly (string & import("effect/Brand").Brand<"Signature">)[];
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+        readonly chain?: string | undefined;
+        readonly expiration?: {
+            readonly $kind: "None";
+            readonly None: true;
+        } | {
+            readonly $kind: "Epoch";
+            readonly Epoch: bigint;
+        } | {
+            readonly $kind: "ValidDuring";
+            readonly ValidDuring: {
+                readonly minEpoch: bigint | null;
+                readonly maxEpoch: bigint | null;
+                readonly minTimestamp: bigint | null;
+                readonly maxTimestamp: bigint | null;
+                readonly chain: string;
+                readonly nonce: number;
+            };
+        } | {
+            readonly $kind: "Validity";
+            readonly Validity: {
+                readonly allowedProposers: {
+                    readonly epoch: bigint;
+                    readonly proposers: readonly number[];
+                } | null;
+                readonly minEpoch: bigint | null;
+                readonly maxEpoch: bigint | null;
+                readonly minTimestamp: bigint | null;
+                readonly maxTimestamp: bigint | null;
+                readonly chain: string;
+                readonly nonce: number;
+            };
+        } | undefined;
+    };
+    readonly lastError: string;
+    readonly attempts: number;
+    readonly at: import("effect/DateTime").Utc;
+} | {
+    readonly _tag: "NotApplied";
+    readonly digest: string & import("effect/Brand").Brand<"Digest">;
+    readonly evidence: "expired" | "inputConsumed";
+    readonly at: import("effect/DateTime").Utc;
+} | {
+    readonly _tag: "Signed";
+    readonly digest: string & import("effect/Brand").Brand<"Digest">;
+    readonly signed: {
+        readonly digest: string & import("effect/Brand").Brand<"Digest">;
+        readonly sender: string & import("effect/Brand").Brand<"SuiAddress">;
+        readonly signatures: readonly (string & import("effect/Brand").Brand<"Signature">)[];
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+        readonly chain?: string | undefined;
+        readonly expiration?: {
+            readonly $kind: "None";
+            readonly None: true;
+        } | {
+            readonly $kind: "Epoch";
+            readonly Epoch: bigint;
+        } | {
+            readonly $kind: "ValidDuring";
+            readonly ValidDuring: {
+                readonly minEpoch: bigint | null;
+                readonly maxEpoch: bigint | null;
+                readonly minTimestamp: bigint | null;
+                readonly maxTimestamp: bigint | null;
+                readonly chain: string;
+                readonly nonce: number;
+            };
+        } | {
+            readonly $kind: "Validity";
+            readonly Validity: {
+                readonly allowedProposers: {
+                    readonly epoch: bigint;
+                    readonly proposers: readonly number[];
+                } | null;
+                readonly minEpoch: bigint | null;
+                readonly maxEpoch: bigint | null;
+                readonly minTimestamp: bigint | null;
+                readonly maxTimestamp: bigint | null;
+                readonly chain: string;
+                readonly nonce: number;
+            };
+        } | undefined;
+    };
+    readonly signedAt: import("effect/DateTime").Utc;
+} | {
+    readonly at: import("effect/DateTime").Utc;
+    readonly digest: string & import("effect/Brand").Brand<"Digest">;
+    readonly _tag: "Executed";
+    readonly checkpoint?: bigint | undefined;
+} | {
+    readonly _tag: "Failed";
+    readonly digest: string & import("effect/Brand").Brand<"Digest">;
+    readonly reason: {
+        readonly $kind: "MoveAbort";
+        readonly MoveAbort: {
+            readonly abortCode: bigint;
+            readonly location?: {
+                readonly function?: number | undefined;
+                readonly package?: string | undefined;
+                readonly module?: string | undefined;
+                readonly functionName?: string | undefined;
+                readonly instruction?: number | undefined;
+            } | undefined;
+            readonly cleverError?: {
+                readonly value?: string | undefined;
+                readonly errorCode?: number | undefined;
+                readonly lineNumber?: number | undefined;
+                readonly constantName?: string | undefined;
+                readonly constantType?: string | undefined;
+            } | undefined;
+        };
+    } | {
+        readonly $kind: "SizeError";
+        readonly SizeError: {
+            readonly name: string;
+            readonly size: number;
+            readonly maxSize: number;
+        };
+    } | {
+        readonly $kind: "CommandArgumentError";
+        readonly CommandArgumentError: {
+            readonly argument: number;
+            readonly name: string;
+        };
+    } | {
+        readonly $kind: "TypeArgumentError";
+        readonly TypeArgumentError: {
+            readonly typeArgument: number;
+            readonly name: string;
+        };
+    } | {
+        readonly $kind: "PackageUpgradeError";
+        readonly PackageUpgradeError: {
+            readonly name: string;
+            readonly digest?: string | undefined;
+            readonly packageId?: string | undefined;
+        };
+    } | {
+        readonly $kind: "IndexError";
+        readonly IndexError: {
+            readonly index?: number | undefined;
+            readonly subresult?: number | undefined;
+        };
+    } | {
+        readonly $kind: "CoinDenyListError";
+        readonly CoinDenyListError: {
+            readonly coinType: string;
+            readonly name: string;
+            readonly address?: string | undefined;
+        };
+    } | {
+        readonly $kind: "CongestedObjects";
+        readonly CongestedObjects: {
+            readonly name: string;
+            readonly objects: readonly string[];
+        };
+    } | {
+        readonly $kind: "ObjectIdError";
+        readonly ObjectIdError: {
+            readonly objectId: string;
+            readonly name?: string | undefined;
+        };
+    } | {
+        readonly $kind: "Unknown";
+    };
+    readonly at: import("effect/DateTime").Utc;
+}) => value is {
+    readonly _tag: "Unknown";
+    readonly digest: string & import("effect/Brand").Brand<"Digest">;
+    readonly signed: {
+        readonly digest: string & import("effect/Brand").Brand<"Digest">;
+        readonly sender: string & import("effect/Brand").Brand<"SuiAddress">;
+        readonly signatures: readonly (string & import("effect/Brand").Brand<"Signature">)[];
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+        readonly chain?: string | undefined;
+        readonly expiration?: {
+            readonly $kind: "None";
+            readonly None: true;
+        } | {
+            readonly $kind: "Epoch";
+            readonly Epoch: bigint;
+        } | {
+            readonly $kind: "ValidDuring";
+            readonly ValidDuring: {
+                readonly minEpoch: bigint | null;
+                readonly maxEpoch: bigint | null;
+                readonly minTimestamp: bigint | null;
+                readonly maxTimestamp: bigint | null;
+                readonly chain: string;
+                readonly nonce: number;
+            };
+        } | {
+            readonly $kind: "Validity";
+            readonly Validity: {
+                readonly allowedProposers: {
+                    readonly epoch: bigint;
+                    readonly proposers: readonly number[];
+                } | null;
+                readonly minEpoch: bigint | null;
+                readonly maxEpoch: bigint | null;
+                readonly minTimestamp: bigint | null;
+                readonly maxTimestamp: bigint | null;
+                readonly chain: string;
+                readonly nonce: number;
+            };
+        } | undefined;
+    };
+    readonly lastError: string;
+    readonly attempts: number;
+    readonly at: import("effect/DateTime").Utc;
+} | {
+    readonly _tag: "Signed";
+    readonly digest: string & import("effect/Brand").Brand<"Digest">;
+    readonly signed: {
+        readonly digest: string & import("effect/Brand").Brand<"Digest">;
+        readonly sender: string & import("effect/Brand").Brand<"SuiAddress">;
+        readonly signatures: readonly (string & import("effect/Brand").Brand<"Signature">)[];
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+        readonly chain?: string | undefined;
+        readonly expiration?: {
+            readonly $kind: "None";
+            readonly None: true;
+        } | {
+            readonly $kind: "Epoch";
+            readonly Epoch: bigint;
+        } | {
+            readonly $kind: "ValidDuring";
+            readonly ValidDuring: {
+                readonly minEpoch: bigint | null;
+                readonly maxEpoch: bigint | null;
+                readonly minTimestamp: bigint | null;
+                readonly maxTimestamp: bigint | null;
+                readonly chain: string;
+                readonly nonce: number;
+            };
+        } | {
+            readonly $kind: "Validity";
+            readonly Validity: {
+                readonly allowedProposers: {
+                    readonly epoch: bigint;
+                    readonly proposers: readonly number[];
+                } | null;
+                readonly minEpoch: bigint | null;
+                readonly maxEpoch: bigint | null;
+                readonly minTimestamp: bigint | null;
+                readonly maxTimestamp: bigint | null;
+                readonly chain: string;
+                readonly nonce: number;
+            };
+        } | undefined;
+    };
+    readonly signedAt: import("effect/DateTime").Utc;
+};
+//# sourceMappingURL=journal-entry.d.ts.map

package/dist/domain/journal-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-entry.d.ts","sourceRoot":"","sources":["../../src/domain/journal-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAG/B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BvB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAEnD,oEAAoE;AACpE,eAAO,MAAM,eAAe,gCAAiC,CAAA;AAE7D;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwC,CAAA"}

package/dist/domain/journal-entry.js

@@ -0,0 +1,63 @@
+/**
+ * `JournalEntry`: the transaction lifecycle as a serializable union.
+ *
+ * This is the only place the lifecycle appears as a union; the abstraction a
+ * program uses is the functions in `Tx`. An entry exists so that a process that
+ * dies between signing and the answer can find out, when it comes back, what it
+ * had already put on the wire.
+ *
+ * @since 0.1.0
+ */
+import { Schema } from "effect";
+import { Digest, ExecutionReason, NotAppliedEvidence, SignedTransaction } from "./schemas.js";
+/**
+ * One line of the submission journal.
+ *
+ * `Signed` is written before the first `executeTransaction` and means the bytes
+ * may be on the wire. `Executed`, `Failed` and `NotApplied` are terminal:
+ * `Executed` and `Failed` because the network answered, `NotApplied` because
+ * the transaction was proven never to have applied and never will. `Unknown`
+ * means the answer never arrived and the bytes are kept so `Tx.reconcile` can
+ * settle it later.
+ *
+ * Without a terminal `NotApplied`, a durable journal would hold a proven-dead
+ * submission as `Unknown` forever and `onUnresolved: "fail"` would refuse to
+ * build for the life of the store.
+ */
+export const JournalEntry = Schema.TaggedUnion({
+    Signed: {
+        digest: Digest,
+        signed: SignedTransaction,
+        signedAt: Schema.DateTimeUtcFromMillis
+    },
+    Executed: {
+        digest: Digest,
+        checkpoint: Schema.optional(Schema.BigIntFromString),
+        at: Schema.DateTimeUtcFromMillis
+    },
+    Failed: {
+        digest: Digest,
+        reason: ExecutionReason,
+        at: Schema.DateTimeUtcFromMillis
+    },
+    Unknown: {
+        digest: Digest,
+        signed: SignedTransaction,
+        lastError: Schema.String,
+        attempts: Schema.Number,
+        at: Schema.DateTimeUtcFromMillis
+    },
+    NotApplied: {
+        digest: Digest,
+        evidence: NotAppliedEvidence,
+        at: Schema.DateTimeUtcFromMillis
+    }
+});
+/** The tags whose entries still need an answer from the network. */
+export const UNRESOLVED_TAGS = ["Signed", "Unknown"];
+/**
+ * Whether this entry is still waiting for an answer, and therefore something
+ * `Tx.reconcileAll` has work to do about. Never fails.
+ */
+export const isUnresolved = JournalEntry.isAnyOf(UNRESOLVED_TAGS);
+//# sourceMappingURL=journal-entry.js.map

package/dist/domain/journal-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-entry.js","sourceRoot":"","sources":["../../src/domain/journal-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAE7F;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC;IAC7C,MAAM,EAAE;QACN,MAAM,EAAE,MAAM;QACd,MAAM,EAAE,iBAAiB;QACzB,QAAQ,EAAE,MAAM,CAAC,qBAAqB;KACvC;IACD,QAAQ,EAAE;QACR,MAAM,EAAE,MAAM;QACd,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,gBAAgB,CAAC;QACpD,EAAE,EAAE,MAAM,CAAC,qBAAqB;KACjC;IACD,MAAM,EAAE;QACN,MAAM,EAAE,MAAM;QACd,MAAM,EAAE,eAAe;QACvB,EAAE,EAAE,MAAM,CAAC,qBAAqB;KACjC;IACD,OAAO,EAAE;QACP,MAAM,EAAE,MAAM;QACd,MAAM,EAAE,iBAAiB;QACzB,SAAS,EAAE,MAAM,CAAC,MAAM;QACxB,QAAQ,EAAE,MAAM,CAAC,MAAM;QACvB,EAAE,EAAE,MAAM,CAAC,qBAAqB;KACjC;IACD,UAAU,EAAE;QACV,MAAM,EAAE,MAAM;QACd,QAAQ,EAAE,kBAAkB;QAC5B,EAAE,EAAE,MAAM,CAAC,qBAAqB;KACjC;CACF,CAAC,CAAA;AAGF,oEAAoE;AACpE,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAU,CAAA;AAE7D;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA"}