@unconfirmed/sui-effect 0.1.0

package/dist/domain/errors.d.ts

@@ -0,0 +1,595 @@
+/**
+ * The closed error taxonomy. Every failure sui-effect can produce is one of the
+ * classes in this file, every one is a `Schema.TaggedError` so it serializes,
+ * and the tags are flat: there is no error inheritance to match on.
+ *
+ * @since 0.1.0
+ */
+import { Schema } from "effect";
+import { Digest } from "./schemas.ts";
+export { CleverError, ExecutionReason, MoveLocation } from "./schemas.ts";
+declare const TransportError_base: Schema.Class<TransportError, Schema.TaggedStruct<"TransportError", {
+    readonly method: Schema.String;
+    readonly retryable: Schema.Boolean;
+    readonly status: Schema.optional<Schema.String>;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A request did not reach a usable answer. `retryable` is true for the statuses
+ * a read may be retried on: gRPC `UNAVAILABLE`, `DEADLINE_EXCEEDED`,
+ * `RESOURCE_EXHAUSTED`, `INTERNAL` and `UNKNOWN`, HTTP 5xx and 429, and
+ * timeouts. `INTERNAL` and `UNKNOWN` are in the set because the grpc-web
+ * transport reports a refused connection or a DNS failure as `INTERNAL` and an
+ * HTTP 500 as `UNKNOWN`, so without them a node that is merely down is never
+ * retried.
+ */
+export declare class TransportError extends TransportError_base {
+    /**
+     * Builds a `TransportError` out of whatever a call threw, classifying the
+     * status and the retryability the way `SuiCore` does for the SDK's own
+     * failures.
+     *
+     * This is for an extension that makes its own network calls — an operator
+     * HTTP API, a GraphQL endpoint, a sidecar — and wants its failures to sit on
+     * the same axis as the library's: `retryable` read off a gRPC status name, an
+     * HTTP status number (5xx and 429), or an abort or timeout, and `status`
+     * recorded as the node or the transport spelled it. Hand-building the three
+     * fields per call site is how they drift.
+     *
+     * `retryable` may be forced when the caller knows better than the shape of
+     * the cause — an idempotent read that is always safe to repeat, a write that
+     * never is. Left out, it is inferred, and inferred conservatively: an
+     * unrecognisable cause is **not** retryable.
+     *
+     * Never fails.
+     *
+     * @example
+     * ```ts
+     * import { TransportError } from "@unconfirmed/sui-effect"
+     * import { Effect } from "effect"
+     *
+     * const status = Effect.tryPromise({
+     *   try: (signal) => fetch("https://operator.example/status", { signal }),
+     *   catch: (cause) => TransportError.fromUnknown("operator.status", cause)
+     * })
+     * ```
+     */
+    static readonly fromUnknown: (method: string, cause: unknown, retryable?: boolean) => TransportError;
+}
+/**
+ * gRPC status names a read may be retried on, plus HTTP 5xx and 429. Timeouts
+ * map to `DEADLINE_EXCEEDED` with `retryable: true`.
+ *
+ * `INTERNAL` and `UNKNOWN` are transport-level failures, not answers from the
+ * node: `@protobuf-ts/grpcweb-transport` turns a rejected `fetch` (connection
+ * refused, DNS failure) into an `RpcError` with code `INTERNAL`, and its
+ * grpc-web format maps HTTP 500 to `UNKNOWN` (503 to `UNAVAILABLE`, 504 to
+ * `DEADLINE_EXCEEDED`, 429 to `RESOURCE_EXHAUSTED`). Without them a read
+ * against a node that is merely down or restarting is never retried.
+ */
+export declare const RETRYABLE_GRPC_STATUSES: ReadonlySet<string>;
+/**
+ * The `status` and `retryable` of a thrown value: a timeout or an abort, an
+ * HTTP status number, a gRPC status name, or nothing recognisable. Never fails.
+ */
+export declare const classifyTransportCause: (cause: unknown) => {
+    readonly status?: string;
+    readonly retryable: boolean;
+};
+declare const ObjectNotFound_base: Schema.Class<ObjectNotFound, Schema.TaggedStruct<"ObjectNotFound", {
+    readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly version: Schema.optional<Schema.brand<Schema.BigIntFromString, "Version">>;
+}>, import("effect/Cause").YieldableError>;
+/** The object does not exist, or has never existed. */
+export declare class ObjectNotFound extends ObjectNotFound_base {
+}
+declare const ObjectDeleted_base: Schema.Class<ObjectDeleted, Schema.TaggedStruct<"ObjectDeleted", {
+    readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly version: Schema.optional<Schema.brand<Schema.BigIntFromString, "Version">>;
+}>, import("effect/Cause").YieldableError>;
+/** The object existed and has been deleted or wrapped. */
+export declare class ObjectDeleted extends ObjectDeleted_base {
+}
+declare const ObjectUnavailable_base: Schema.Class<ObjectUnavailable, Schema.TaggedStruct<"ObjectUnavailable", {
+    readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+    readonly version: Schema.optional<Schema.brand<Schema.BigIntFromString, "Version">>;
+}>, import("effect/Cause").YieldableError>;
+/** The node could not say what happened to the object (`ObjectError.reason: "unknown"`). */
+export declare class ObjectUnavailable extends ObjectUnavailable_base {
+}
+declare const TransactionNotFound_base: Schema.Class<TransactionNotFound, Schema.TaggedStruct<"TransactionNotFound", {
+    readonly digest: Schema.brand<Schema.String, "Digest">;
+}>, import("effect/Cause").YieldableError>;
+/** No transaction with this digest is known to the node. */
+export declare class TransactionNotFound extends TransactionNotFound_base {
+}
+declare const NetworkMismatch_base: Schema.Class<NetworkMismatch, Schema.TaggedStruct<"NetworkMismatch", {
+    readonly expected: Schema.String;
+    readonly actual: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The chain identifier the node reported is not the one the layer was built for. */
+export declare class NetworkMismatch extends NetworkMismatch_base {
+}
+declare const DecodeError_base: Schema.Class<DecodeError, Schema.TaggedStruct<"DecodeError", {
+    readonly objectId: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">>;
+    readonly expectedType: Schema.optional<Schema.String>;
+    readonly issue: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** BCS content or a schema boundary did not decode. */
+export declare class DecodeError extends DecodeError_base {
+}
+declare const SimulationFailed_base: Schema.Class<SimulationFailed, Schema.TaggedStruct<"SimulationFailed", {
+    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 message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Simulation reported an execution failure. No gas was charged. */
+export declare class SimulationFailed extends SimulationFailed_base {
+}
+declare const ExecutionFailed_base: Schema.Class<ExecutionFailed, Schema.TaggedStruct<"ExecutionFailed", {
+    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 command: Schema.optional<Schema.Number>;
+    readonly effects: Schema.Struct<{
+        readonly version: Schema.Number;
+        readonly status: Schema.Struct<{
+            readonly success: Schema.Boolean;
+        }>;
+        readonly gasUsed: Schema.Struct<{
+            readonly computationCost: Schema.brand<Schema.BigIntFromString, "Mist">;
+            readonly storageCost: Schema.brand<Schema.BigIntFromString, "Mist">;
+            readonly storageRebate: Schema.brand<Schema.BigIntFromString, "Mist">;
+            readonly nonRefundableStorageFee: Schema.brand<Schema.BigIntFromString, "Mist">;
+        }>;
+        readonly transactionDigest: Schema.brand<Schema.String, "Digest">;
+        readonly gasObject: Schema.NullOr<Schema.Struct<{
+            readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            readonly inputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "Exists"]>;
+            readonly inputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+            readonly inputDigest: Schema.NullOr<Schema.String>;
+            readonly inputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+                readonly $kind: Schema.Literal<"AddressOwner">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ObjectOwner">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Shared">;
+                readonly Shared: Schema.Struct<{
+                    readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Immutable">;
+                readonly Immutable: Schema.Literal<true>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+                readonly ConsensusAddressOwner: Schema.Struct<{
+                    readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Unknown">;
+            }>]>>;
+            readonly outputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "ObjectWrite", "PackageWrite", "AccumulatorWriteV1"]>;
+            readonly outputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+            readonly outputDigest: Schema.NullOr<Schema.String>;
+            readonly outputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+                readonly $kind: Schema.Literal<"AddressOwner">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ObjectOwner">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Shared">;
+                readonly Shared: Schema.Struct<{
+                    readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Immutable">;
+                readonly Immutable: Schema.Literal<true>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+                readonly ConsensusAddressOwner: Schema.Struct<{
+                    readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Unknown">;
+            }>]>>;
+            readonly idOperation: Schema.Literals<readonly ["Unknown", "None", "Created", "Deleted"]>;
+        }>>;
+        readonly eventsDigest: Schema.NullOr<Schema.String>;
+        readonly dependencies: Schema.$Array<Schema.String>;
+        readonly lamportVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+        readonly changedObjects: Schema.$Array<Schema.Struct<{
+            readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            readonly inputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "Exists"]>;
+            readonly inputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+            readonly inputDigest: Schema.NullOr<Schema.String>;
+            readonly inputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+                readonly $kind: Schema.Literal<"AddressOwner">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ObjectOwner">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Shared">;
+                readonly Shared: Schema.Struct<{
+                    readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Immutable">;
+                readonly Immutable: Schema.Literal<true>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+                readonly ConsensusAddressOwner: Schema.Struct<{
+                    readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Unknown">;
+            }>]>>;
+            readonly outputState: Schema.Literals<readonly ["Unknown", "DoesNotExist", "ObjectWrite", "PackageWrite", "AccumulatorWriteV1"]>;
+            readonly outputVersion: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+            readonly outputDigest: Schema.NullOr<Schema.String>;
+            readonly outputOwner: Schema.NullOr<Schema.toTaggedUnion<"$kind", readonly [Schema.Struct<{
+                readonly $kind: Schema.Literal<"AddressOwner">;
+                readonly AddressOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ObjectOwner">;
+                readonly ObjectOwner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Shared">;
+                readonly Shared: Schema.Struct<{
+                    readonly initialSharedVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Immutable">;
+                readonly Immutable: Schema.Literal<true>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"ConsensusAddressOwner">;
+                readonly ConsensusAddressOwner: Schema.Struct<{
+                    readonly startVersion: Schema.brand<Schema.BigIntFromString, "Version">;
+                    readonly owner: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "SuiAddress">;
+                }>;
+            }>, Schema.Struct<{
+                readonly $kind: Schema.Literal<"Unknown">;
+            }>]>>;
+            readonly idOperation: Schema.Literals<readonly ["Unknown", "None", "Created", "Deleted"]>;
+        }>>;
+        readonly unchangedConsensusObjects: Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["Unknown", "ReadOnlyRoot", "MutateConsensusStreamEnded", "ReadConsensusStreamEnded", "Cancelled", "PerEpochConfig"]>;
+            readonly objectId: Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">;
+            readonly version: Schema.NullOr<Schema.brand<Schema.BigIntFromString, "Version">>;
+            readonly digest: Schema.NullOr<Schema.String>;
+        }>>;
+        readonly auxiliaryDataDigest: Schema.NullOr<Schema.String>;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+/** The transaction was applied on chain and failed. Gas was charged. */
+export declare class ExecutionFailed extends ExecutionFailed_base {
+}
+declare const SubmissionUnknown_base: Schema.Class<SubmissionUnknown, Schema.TaggedStruct<"SubmissionUnknown", {
+    readonly digest: Schema.brand<Schema.String, "Digest">;
+    readonly signed: Schema.optional<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 cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Bytes may have reached the network and the outcome is unknown. Carries the
+ * signed transaction so an operator or a later process can reconcile it.
+ */
+export declare class SubmissionUnknown extends SubmissionUnknown_base {
+}
+declare const NotApplied_base: Schema.Class<NotApplied, Schema.TaggedStruct<"NotApplied", {
+    readonly digest: Schema.brand<Schema.String, "Digest">;
+    readonly evidence: Schema.Literals<readonly ["expired", "inputConsumed"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The transaction provably cannot have been applied, and never will be.
+ *
+ * `evidence` is why. `"inputConsumed"` is only ever produced when a
+ * **different** transaction's own effects report that it took a pinned object
+ * at exactly the version these bytes pinned. An owned input that merely moved
+ * on, one whose consumer took a later version, and one whose last mutation the
+ * node will not name are all `SubmissionUnknown`, not this.
+ */
+export declare class NotApplied extends NotApplied_base {
+}
+declare const SigningError_base: Schema.Class<SigningError, Schema.TaggedStruct<"SigningError", {
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/** A signer refused or failed to produce a signature. */
+export declare class SigningError extends SigningError_base {
+}
+declare const BuildError_base: Schema.Class<BuildError, Schema.TaggedStruct<"BuildError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/** The transaction could not be built into bytes. */
+export declare class BuildError extends BuildError_base {
+}
+declare const PolicyDenied_base: Schema.Class<PolicyDenied, Schema.TaggedStruct<"PolicyDenied", {
+    readonly rule: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A preflight policy refused the transaction before it was signed. */
+export declare class PolicyDenied extends PolicyDenied_base {
+}
+declare const JournalError_base: Schema.Class<JournalError, Schema.TaggedStruct<"JournalError", {
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/** The submission journal could not be read or written. */
+export declare class JournalError extends JournalError_base {
+}
+declare const UnexpectedEffects_base: Schema.Class<UnexpectedEffects, Schema.TaggedStruct<"UnexpectedEffects", {
+    readonly digest: Schema.brand<Schema.String, "Digest">;
+    readonly expected: Schema.String;
+    readonly found: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.toType<Schema.String>, Schema.String, never, never>, "ObjectId">>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The effects of an applied transaction did not contain what the caller
+ * expected.
+ *
+ * Outcome `applied`, and exit 5: this error can only come from an `Executed`,
+ * which means the transaction reached the chain and gas was charged. What is
+ * missing is a receipt, not the transaction. Classifying it `not_applied`
+ * would tell the documented retry idiom to send the caller's intent a second
+ * time for a transaction that already ran.
+ */
+export declare class UnexpectedEffects extends UnexpectedEffects_base {
+}
+declare const GraphQLUnavailable_base: Schema.Class<GraphQLUnavailable, Schema.TaggedStruct<"GraphQLUnavailable", {
+    readonly method: Schema.String;
+    readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The GraphQL endpoint an extension needs is not usable: none was configured,
+ * or the one that was could not be reached.
+ *
+ * sui-effect does not wrap the GraphQL API — it owns the {@link SuiGraphQL}
+ * *tag*, so two extensions that both read GraphQL share one client rather than
+ * opening two. This is the failure the tag's `layerUnavailable` produces, which
+ * is what an application provides when it has no endpoint: every call rejects
+ * with this instead of the extension discovering a missing dependency at
+ * construction. An extension maps it into its own union, or lets it through.
+ *
+ * Outcome `not_applied`: a read that did not happen changed nothing.
+ */
+export declare class GraphQLUnavailable extends GraphQLUnavailable_base {
+}
+declare const ExtensionNotReady_base: Schema.Class<ExtensionNotReady, Schema.TaggedStruct<"ExtensionNotReady", {
+    readonly extension: Schema.String;
+    readonly member: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A synchronous member of a Promise-faced extension was called before its
+ * runtime existed.
+ *
+ * `SuiExtension.fromService` builds its `ManagedRuntime` on first use, so until
+ * something has been awaited there is no service object and no synchronous
+ * member to read. Rather than hand back a Promise where the type says a value,
+ * the face throws this. Two cures, both in the extension's own hands:
+ * `await client.<name>.$ready()` once after registering, or register with
+ * `warm`, which builds the runtime inside `register` and makes every member
+ * real immediately.
+ *
+ * Outcome `not_applied`: nothing was sent.
+ */
+export declare class ExtensionNotReady extends ExtensionNotReady_base {
+}
+/** Every failure sui-effect can produce. */
+export type SuiError = TransportError | ObjectNotFound | ObjectDeleted | ObjectUnavailable | TransactionNotFound | NetworkMismatch | DecodeError | SimulationFailed | ExecutionFailed | SubmissionUnknown | NotApplied | SigningError | BuildError | PolicyDenied | JournalError | UnexpectedEffects | GraphQLUnavailable | ExtensionNotReady;
+/** The schema of the whole taxonomy, used for serialization. */
+export declare const SuiErrorSchema: Schema.Union<readonly [typeof TransportError, typeof ObjectNotFound, typeof ObjectDeleted, typeof ObjectUnavailable, typeof TransactionNotFound, typeof NetworkMismatch, typeof DecodeError, typeof SimulationFailed, typeof ExecutionFailed, typeof SubmissionUnknown, typeof NotApplied, typeof SigningError, typeof BuildError, typeof PolicyDenied, typeof JournalError, typeof UnexpectedEffects, typeof GraphQLUnavailable, typeof ExtensionNotReady]>;
+/**
+ * What a failure says about the transaction it came from, on the axis a caller
+ * or a wrapper script acts on.
+ */
+export type Outcome = "applied" | "not_applied" | "unknown";
+/**
+ * An extension error may declare its own `outcome`, and `SuiError.outcome` and
+ * `Script.run` honour it before anything else.
+ *
+ * An error that declares none and carries a tag the taxonomy does not own is
+ * `"unknown"`, not `"not_applied"`: a tag this library has never heard of says
+ * nothing about whether a transaction applied, and `"not_applied"` would tell
+ * the documented retry idiom to send again on no evidence at all.
+ */
+export interface HasOutcome {
+    readonly outcome: Outcome;
+}
+/**
+ * The four helpers every repo hand-rolls: is this worth retrying, did the
+ * transaction land, what does an operator need to read, and what goes in a log.
+ */
+export declare const SuiError: {
+    readonly isRetryable: (error: SuiError) => boolean;
+    readonly outcome: (error: SuiError | HasOutcome) => Outcome;
+    readonly describe: (error: SuiError) => string;
+    readonly toJson: (error: SuiError | {
+        readonly _tag: string;
+    }) => Record<string, unknown>;
+};
+/** The digest of the transaction a failure refers to, when it has one. */
+export declare const digestOf: (error: SuiError) => Digest | undefined;
+//# sourceMappingURL=errors.d.ts.map

package/dist/domain/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/domain/errors.ts"],"names":[],"mappings":"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"}