sui-effect 0.1.0

package/dist/services/Tx.d.ts

@@ -0,0 +1,687 @@
+import { Transaction } from "@mysten/sui/transactions";
+import { Effect, Schema } from "effect";
+import { BuildError, ExecutionFailed, JournalError, NotApplied, PolicyDenied, SigningError, SimulationFailed, SubmissionUnknown, TransportError } from "../domain/errors.ts";
+import { Executed } from "../domain/executed.ts";
+import { Digest, SignedTransaction, SuiAddress } from "../domain/schemas.ts";
+import type { Signer } from "./Signer.ts";
+import type { Recipe } from "./Sui.ts";
+import { Sui } from "./Sui.ts";
+/** A transaction built into bytes, with the expiration the builder settled on. */
+export type { Built } from "../domain/schemas.ts";
+/** Signed bytes: everything `executeTransaction` needs, plus what `reconcile` needs. */
+export type Signed = SignedTransaction;
+/** The schema of {@link Signed}. */
+export declare const 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>;
+}>;
+/** What `Tx.reconcile` can be asked about. */
+export type ReconcileInput = Digest | Signed | SubmissionUnknown;
+/**
+ * Everything {@link submit} can fail with, as one name.
+ *
+ * An extension that wraps a submission spells its own errors plus this, rather
+ * than repeating four tags that will grow with the taxonomy.
+ */
+export type SubmitError = ExecutionFailed | NotApplied | SubmissionUnknown | JournalError;
+/**
+ * Everything {@link run} can fail with, as one name: {@link SubmitError} plus
+ * what building, preflighting and signing can produce.
+ */
+export type RunError = BuildError | SimulationFailed | PolicyDenied | SigningError | SubmitError | TransportError;
+/** What one entry of `Tx.reconcileAll` settled to. */
+export type Reconciled = Executed | ExecutionFailed | NotApplied | SubmissionUnknown;
+/**
+ * Builds a transaction into signable bytes.
+ *
+ * **Building always simulates.** On gRPC the SDK's resolve plugin simulates
+ * with checks enabled to choose the gas budget, and an execution failure there
+ * arrives as `SimulationFailed`. That costs nothing extra — but the resolver
+ * returns early for a transaction that was **already fully resolved** (every
+ * input resolved, gas price, budget and payment set), and then nothing
+ * simulates at all. `Tx.build` detects that case and runs one explicit
+ * `simulateTransaction` with checks enabled, so simulate-before-submit holds
+ * for every transaction: it costs nothing extra when the SDK had to resolve,
+ * and one call otherwise.
+ *
+ * An interrupted build cancels the request it started: the SDK is handed a
+ * client whose Core calls carry the Effect's `AbortSignal`.
+ *
+ * When the recipe set no expiration, `SubmitConfig.expiration` decides one.
+ * The default, `ValidDuring`, bounds the transaction to the **current epoch and
+ * the next**, names the chain (bytes signed for testnet cannot land on mainnet)
+ * and carries a `u32` nonce from `SubmitConfig.nonce`. There is **no
+ * wall-clock bound** unless `SubmitConfig.validFor` asks for one: no Sui
+ * network accepts a timestamp expiration yet, and a node refuses any
+ * transaction carrying one. The expiration that ends up in the bytes is
+ * recorded on the result, because it is what `Tx.reconcile` needs later to
+ * prove a transaction can no longer land.
+ *
+ * `Tx.build` takes no sender lock; `Tx.run` is what holds one from build
+ * through submit. Called on its own, two concurrent builds for one address can
+ * pick the same gas coin.
+ *
+ * Fails with: `BuildError` (the recipe threw, an input could not be resolved,
+ * or the budget the node chose is over `SubmitConfig.maxGasBudget`),
+ * `SimulationFailed` (the transaction would abort on chain),
+ * `TransportError`.
+ */
+export declare const build: (input: Transaction | Recipe, opts: {
+    readonly sender: SuiAddress;
+    readonly gasOwner?: SuiAddress;
+}) => Effect.Effect<{
+    readonly digest: string & import("effect/Brand").Brand<"Digest">;
+    readonly sender: string & import("effect/Brand").Brand<"SuiAddress">;
+    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 gasOwner?: (string & import("effect/Brand").Brand<"SuiAddress">) | undefined;
+}, TransportError | SimulationFailed | BuildError, Sui>;
+/**
+ * Signs built bytes.
+ *
+ * The signer's address must be the transaction's sender or, for a sponsored
+ * transaction, its gas owner; anything else is a `SigningError` rather than a
+ * rejection at execution time. A `Signer.remote` therefore has to report the
+ * address it signs as truthfully.
+ *
+ * Fails with: `SigningError`.
+ */
+export declare const sign: (built: {
+    readonly digest: string & import("effect/Brand").Brand<"Digest">;
+    readonly sender: string & import("effect/Brand").Brand<"SuiAddress">;
+    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 gasOwner?: (string & import("effect/Brand").Brand<"SuiAddress">) | undefined;
+}, signer: Signer) => Effect.Effect<{
+    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;
+}, SigningError, never>;
+/**
+ * Adds one more signature to already signed bytes, for a sponsored or
+ * multi-party transaction. The bytes are untouched, so both parties sign
+ * exactly the same transaction.
+ *
+ * As in {@link sign}, the co-signer's address must be the sender or the gas
+ * owner named in the bytes.
+ *
+ * Fails with: `SigningError`.
+ */
+export declare const cosign: (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;
+}, signer: Signer) => Effect.Effect<{
+    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;
+}, SigningError, never>;
+/**
+ * Turns a recipe into a sponsored one: the sender owns the transaction, the
+ * gas owner pays, and gas comes from the sponsor's address balance rather than
+ * from coin objects, so the two parties never have to agree on a gas coin and
+ * can sign in either order.
+ *
+ * Never fails; the recipe it returns throws only if the recipe it wraps does,
+ * which `Tx.build` reports as `BuildError`.
+ */
+export declare const sponsored: (opts: {
+    readonly sender: SuiAddress;
+    readonly gasOwner: SuiAddress;
+}) => (recipe: Recipe) => Recipe;
+/**
+ * Sends signed bytes, and does not stop caring until it knows what happened.
+ *
+ * Before the first `executeTransaction` it writes a `Signed` journal entry, so
+ * a process that dies mid-flight leaves a record of bytes that may be on the
+ * wire. A retryable transport failure or a timeout re-sends the identical bytes
+ * on `SubmitConfig.resubmit`; nothing is ever rebuilt, so a retry can only land
+ * the transaction that was already signed. When the retries run out it runs
+ * `Tx.reconcile`, which either finds the transaction, proves it never applied,
+ * or says it does not know.
+ *
+ * `TransportError` never escapes: once bytes may have been sent, "the network
+ * was unreachable" is not an answer a caller can act on, so it becomes
+ * `SubmissionUnknown` carrying the signed bytes.
+ *
+ * `JournalError` can only come from the `Signed` write, before anything has
+ * been sent. Once the network has answered, a journal write that fails is
+ * logged with `Effect.logError` and the answer stands, because "the journal is
+ * broken" is not a thing a caller can act on and reporting it in place of a
+ * charged `ExecutionFailed` would invite a second submission.
+ *
+ * Fails with: `ExecutionFailed` (applied on chain and failed; gas was charged),
+ * `NotApplied` (provably never applied), `SubmissionUnknown` (the outcome is
+ * not known and the bytes are in the error), `JournalError` (only before the
+ * first send).
+ */
+export declare const submit: (signed: Signed) => Effect.Effect<Executed, SubmitError, Sui>;
+/**
+ * Finds out what happened to a transaction that was sent but never answered
+ * for.
+ *
+ * A transaction the node knows is `Executed`, or `ExecutionFailed` when it
+ * applied and aborted. A transaction the node does not know is only ever
+ * `NotApplied` on evidence, and there are exactly two kinds:
+ *
+ * - `"expired"`, under an **ordered and repeated** rule, because a closed
+ *   expiration window proves only that the bytes cannot execute *later*, not
+ *   that they did not execute *earlier*, and a transaction can execute between
+ *   a lookup and an expiry check. So: the window must be observed closed, then
+ *   `getTransaction` must miss, then — after `SubmitConfig.reconcileRecheck`
+ *   (two seconds by default, through the `Clock`) — both must hold again. Any
+ *   other order, or a single observation, is `SubmissionUnknown`. Set
+ *   `SubmitConfig.expiryEvidence: "never"` to disable the rule entirely, which
+ *   is what a deployment behind a mixed-node load balancer wants. The residual
+ *   risk is a node whose transaction index lags its epoch view;
+ * - `"inputConsumed"` when the transaction that last mutated a pinned object is
+ *   a **different** one **and its own effects report `inputVersion` equal to
+ *   the version these bytes pinned**, so those exact bytes can never execute
+ *   again.
+ *
+ * An input that merely advanced is not evidence: the transaction being
+ * reconciled is itself the likeliest thing to have advanced it, and calling
+ * that `NotApplied` would tell the documented retry idiom to execute the
+ * caller's intent a second time. When the live object names *our* digest the
+ * transaction applied and `getTransaction` is asked again; when the consuming
+ * transaction took a **later** version than ours — which is the common case,
+ * because Sui stamps every output with the transaction's Lamport version and
+ * the object "one version on" from ours usually never existed — nothing is
+ * proven and the answer is `SubmissionUnknown`, which carries the bytes so a
+ * later process, or a person, can settle it. Every pinned reference is tried
+ * before that answer is given.
+ *
+ * **Chain identity is checked before anything is asked.** Bytes built for one
+ * chain must never be declared expired by another chain's epoch, which a
+ * process-wide journal holding two networks' submissions makes easy to do. A
+ * mismatch is `SubmissionUnknown` naming both chains.
+ *
+ * **No `TransportError` escapes.** A recovery read that fails says nothing
+ * about whether the transaction applied, and `SuiError.outcome` puts
+ * `TransportError` on `"not_applied"` — which would tell a wrapper to retry a
+ * submission whose outcome is genuinely unknown. Every read failure here
+ * becomes `SubmissionUnknown` carrying the digest, the bytes and the cause. The
+ * tag stays in the signature so the union does not shrink under callers.
+ *
+ * Given only a `Digest` there can be no evidence, so an unknown transaction is
+ * always `SubmissionUnknown`. Pass the `Signed` bytes (or the
+ * `SubmissionUnknown` that carries them) to get the evidence rules.
+ *
+ * Fails with: `ExecutionFailed`, `NotApplied`, `SubmissionUnknown`,
+ * `TransportError`.
+ */
+export declare const reconcile: (input: ReconcileInput) => Effect.Effect<Executed, TransportError | ExecutionFailed | SubmissionUnknown | NotApplied, Sui>;
+/**
+ * Build, preflight, sign and submit, with the sender lock held throughout.
+ *
+ * Gas coins are chosen during build, so two transactions from one address that
+ * overlap can pick the same coin and one of them will fail on chain. `Tx.run`
+ * holds the sender lock from build through submit, which is the whole reason to
+ * prefer it over calling the steps separately.
+ *
+ * The address that matters is the one whose coins are being spent, which is the
+ * **gas owner** when there is one: two sponsored runs for different senders
+ * paid by one sponsor are exactly the case that picks the same coin twice. When
+ * sender and gas owner differ, both locks are held, in ascending address order
+ * — a fixed order, so two runs that each need the same pair cannot deadlock by
+ * taking them the other way round.
+ *
+ * When `SubmitConfig.preflight` is set it costs one extra simulate, and is
+ * where spend limits and target policies refuse a transaction before anything
+ * is signed.
+ *
+ * **A sponsored run needs both signatures.** A transaction whose gas owner is
+ * not its sender is signed by *both* parties; one signature is bytes a
+ * validator rejects. So when `opts.gasOwner` differs from the signer's address
+ * — or when the recipe itself set a different gas owner, which `Tx.sponsored`
+ * does — `opts.sponsor` is required and co-signs the same bytes. Without it
+ * `Tx.run` fails with `SigningError` naming the address whose signature is
+ * missing, before anything is built when the gas owner was given as an option
+ * and immediately after the build when it came out of the recipe. Use the
+ * explicit lifecycle (`Tx.build`, `Tx.sign`, `Tx.cosign`, `Tx.submit`) when the
+ * two parties cannot both sign in one process.
+ *
+ * Fails with: `BuildError`, `SimulationFailed`, `PolicyDenied`, `SigningError`,
+ * `ExecutionFailed`, `NotApplied`, `SubmissionUnknown`, `JournalError`,
+ * `TransportError` (from the build reads; once bytes are sent, transport
+ * failures become `SubmissionUnknown`).
+ */
+export declare const run: (recipe: Transaction | Recipe, opts: {
+    readonly signer: Signer;
+    readonly gasOwner?: SuiAddress;
+    /**
+     * The gas owner's signer, for a sponsored transaction. Required whenever
+     * the bytes name a gas owner that is not the sender.
+     */
+    readonly sponsor?: Signer;
+}) => Effect.Effect<Executed, TransportError | SimulationFailed | ExecutionFailed | SubmissionUnknown | NotApplied | SigningError | BuildError | PolicyDenied | JournalError, Sui>;
+/**
+ * Settles every unresolved entry in the journal: the explicit startup call a
+ * long-lived application makes after building a durable `Journal`.
+ *
+ * Nothing here fails per entry: each one settles to an `Executed`, an
+ * `ExecutionFailed`, a `NotApplied` or a `SubmissionUnknown`, in the order the
+ * journal listed them, and the journal is updated to match. Every settled entry
+ * gets the same evidence rules `Tx.reconcile` applies — the ordered, repeated
+ * expiry rule, the chain-identity guard and the versioned consumer check — so a
+ * startup never reports a transaction that applied as `NotApplied`, and a
+ * recovery read that fails becomes that entry's `SubmissionUnknown` rather than
+ * escaping as a `TransportError` the taxonomy would call "not applied".
+ *
+ * The whole call fails only if the journal itself cannot be **read**: a write
+ * that fails after an entry has been settled is logged and the answer stands,
+ * the same rule `Tx.submit` follows.
+ *
+ * Fails with: `JournalError`, `TransportError`.
+ */
+export declare const reconcileAll: () => Effect.Effect<readonly Reconciled[], TransportError | JournalError, Sui>;
+/**
+ * The lifecycle, namespaced the way the spec spells it: `Tx.build`, `Tx.sign`,
+ * `Tx.cosign`, `Tx.sponsored`, `Tx.submit`, `Tx.reconcile`, `Tx.run`,
+ * `Tx.reconcileAll`.
+ */
+export declare const Tx: {
+    readonly build: (input: Transaction | Recipe, opts: {
+        readonly sender: SuiAddress;
+        readonly gasOwner?: SuiAddress;
+    }) => Effect.Effect<{
+        readonly digest: string & import("effect/Brand").Brand<"Digest">;
+        readonly sender: string & import("effect/Brand").Brand<"SuiAddress">;
+        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 gasOwner?: (string & import("effect/Brand").Brand<"SuiAddress">) | undefined;
+    }, TransportError | SimulationFailed | BuildError, Sui>;
+    readonly sign: (built: {
+        readonly digest: string & import("effect/Brand").Brand<"Digest">;
+        readonly sender: string & import("effect/Brand").Brand<"SuiAddress">;
+        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 gasOwner?: (string & import("effect/Brand").Brand<"SuiAddress">) | undefined;
+    }, signer: Signer) => Effect.Effect<{
+        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;
+    }, SigningError, never>;
+    readonly cosign: (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;
+    }, signer: Signer) => Effect.Effect<{
+        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;
+    }, SigningError, never>;
+    readonly sponsored: (opts: {
+        readonly sender: SuiAddress;
+        readonly gasOwner: SuiAddress;
+    }) => (recipe: Recipe) => Recipe;
+    readonly submit: (signed: Signed) => Effect.Effect<Executed, SubmitError, Sui>;
+    readonly reconcile: (input: ReconcileInput) => Effect.Effect<Executed, TransportError | ExecutionFailed | SubmissionUnknown | NotApplied, Sui>;
+    readonly run: (recipe: Transaction | Recipe, opts: {
+        readonly signer: Signer;
+        readonly gasOwner?: SuiAddress;
+        /**
+         * The gas owner's signer, for a sponsored transaction. Required whenever
+         * the bytes name a gas owner that is not the sender.
+         */
+        readonly sponsor?: Signer;
+    }) => Effect.Effect<Executed, TransportError | SimulationFailed | ExecutionFailed | SubmissionUnknown | NotApplied | SigningError | BuildError | PolicyDenied | JournalError, Sui>;
+    readonly reconcileAll: () => Effect.Effect<readonly Reconciled[], TransportError | JournalError, Sui>;
+};
+//# sourceMappingURL=Tx.d.ts.map