@lucid-evolution/provider 0.1.97 → 0.2.1

package/dist/index.js

@@ -1,3 +1,93 @@
+// src/errors.ts
+var asRecord = (value) => typeof value === "object" && value !== null ? value : void 0;
+var responseStatus = (cause) => {
+  const response = asRecord(asRecord(cause)?.response);
+  return typeof response?.status === "number" ? response.status : void 0;
+};
+var retryAfterHeaderToMs = (value) => {
+  if (value === void 0) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const timestamp = Date.parse(value);
+  return Number.isNaN(timestamp) ? void 0 : Math.max(0, timestamp - Date.now());
+};
+var retryAfter = (cause) => {
+  const response = asRecord(asRecord(cause)?.response);
+  const headers = asRecord(response?.headers);
+  const value = headers?.["retry-after"];
+  return retryAfterHeaderToMs(typeof value === "string" ? value : void 0);
+};
+var errorTag = (cause) => {
+  const record = asRecord(cause);
+  return [record?._tag, record?.name, record?.reason].filter((value) => typeof value === "string").join(" ").toLowerCase();
+};
+var inferKind = (cause, status) => {
+  const tag = errorTag(cause);
+  if (tag.includes("timeout")) return "timeout";
+  if (tag.includes("parse") || tag.includes("decode")) return "decode";
+  if (status !== void 0) return "http";
+  if (tag.includes("request") || tag.includes("transport")) return "transport";
+  return "unknown";
+};
+var inferRetryable = (kind, status) => kind === "timeout" || kind === "transport" || status === 408 || status === 425 || status === 429 || status !== void 0 && status >= 500;
+var KupmiosError = class extends Error {
+  _tag = "KupmiosError";
+  provider = "Kupmios";
+  protocol;
+  operation;
+  kind;
+  status;
+  retryable;
+  retryAfterMs;
+  cause;
+  constructor(options) {
+    const status = options.status ?? responseStatus(options.cause);
+    const kind = options.kind ?? inferKind(options.cause, status);
+    const retryable = options.retryable ?? inferRetryable(kind, status);
+    const operation = options.operation ?? "unknown";
+    const statusSuffix = status === void 0 ? "" : ` (HTTP ${status})`;
+    super(
+      options.message ?? `${options.protocol ?? "provider"} ${operation} failed${statusSuffix}`,
+      {
+        cause: options.cause
+      }
+    );
+    this.name = "KupmiosError";
+    this.protocol = options.protocol;
+    this.operation = operation;
+    this.kind = kind;
+    this.status = status;
+    this.retryable = retryable;
+    this.retryAfterMs = options.retryAfterMs ?? retryAfter(options.cause);
+    this.cause = options.cause;
+  }
+};
+var OgmiosJsonRpcError = class extends KupmiosError {
+  _tag = "OgmiosJsonRpcError";
+  code;
+  data;
+  method;
+  id;
+  constructor(options) {
+    const dataSuffix = options.data === void 0 ? "" : `: ${JSON.stringify(options.data)}`;
+    super({
+      protocol: "ogmios",
+      operation: options.operation ?? options.method ?? "unknown",
+      kind: "json_rpc",
+      status: options.status,
+      retryAfterMs: options.retryAfterMs,
+      cause: options.cause,
+      message: `Ogmios JSON-RPC error ${options.code}: ${options.message}${dataSuffix}`
+    });
+    this.name = "OgmiosJsonRpcError";
+    this.code = options.code;
+    this.data = options.data;
+    this.method = options.method;
+    this.id = options.id;
+  }
+};
+var toKupmiosError = (cause, protocol, operation) => cause instanceof KupmiosError ? cause : new KupmiosError({ cause, protocol, operation });
+
 // src/core.ts
 import * as CML from "@anastasia-labs/cardano-multiplatform-lib-nodejs";
 
@@ -11,7 +101,7 @@ import {
 // package.json
 var package_default = {
   name: "@lucid-evolution/provider",
-  version: "0.1.97",
+  version: "0.2.1",
   description: "",
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
@@ -254,18 +344,29 @@ var Blockfrost = class {
       )
     );
   }
-  async getDelegation(rewardAddress) {
-    const result = await fetch(`${this.url}/accounts/${rewardAddress}`, {
+  async getRewardAccount(rewardAddress) {
+    const response = await fetch(`${this.url}/accounts/${rewardAddress}`, {
       headers: { project_id: this.projectId, lucid }
-    }).then((res) => res.json());
-    if (!result || result.error) {
-      return { poolId: null, rewards: 0n };
+    });
+    if (response.status === 404) {
+      return { registered: false, poolId: null, rewards: 0n };
+    }
+    if (!response.ok) {
+      throw new Error(
+        `Could not fetch reward account from Blockfrost. Received status code: ${response.status}`
+      );
     }
+    const result = await response.json();
     return {
+      registered: result.active,
       poolId: result.pool_id || null,
       rewards: BigInt(result.withdrawable_amount)
     };
   }
+  async getDelegation(rewardAddress) {
+    const { poolId, rewards } = await this.getRewardAccount(rewardAddress);
+    return { poolId, rewards };
+  }
   async getDatum(datumHash) {
     const datum = await fetch(`${this.url}/scripts/datum/${datumHash}/cbor`, {
       headers: { project_id: this.projectId, lucid }
@@ -289,6 +390,29 @@ var Blockfrost = class {
       }, checkInterval);
     });
   }
+  async getTransactionStatus(txHash, options = {}) {
+    const response = await fetch(`${this.url}/txs/${txHash}`, {
+      headers: { project_id: this.projectId, lucid },
+      signal: options.signal
+    });
+    if (response.status === 404) return { status: "not_found", txHash };
+    if (!response.ok) {
+      throw new Error(
+        `Could not fetch transaction status from Blockfrost. Received status code: ${response.status}`
+      );
+    }
+    const result = await response.json();
+    return {
+      status: "confirmed",
+      txHash,
+      confirmation: {
+        txHash,
+        blockHash: result.block,
+        blockHeight: result.block_height,
+        slot: result.slot
+      }
+    };
+  }
   async submitTx(tx) {
     const result = await fetch(`${this.url}/tx/submit`, {
       method: "POST",
@@ -422,7 +546,7 @@ var lucid = package_default.version;
 // src/kupmios.ts
 import { applyDoubleCborEncoding as applyDoubleCborEncoding2, fromUnit as fromUnit2 } from "@lucid-evolution/utils";
 import { Schema as S3 } from "effect";
-import { Effect as Effect2, pipe as pipe3, Array as _Array, Schedule, Data } from "effect";
+import { Cause, Effect as Effect2, Exit, pipe as pipe3, Array as _Array, Schedule } from "effect";
 
 // src/internal/ogmios.ts
 import { Schema as S } from "effect";
@@ -447,12 +571,28 @@ var JSONRPCErrorResponseSchema = S.Struct({
 var JSONRPCResponseSchema = (schema) => S.Union(JSONRPCSchema(schema), JSONRPCErrorResponseSchema).annotations({
   identifier: "JSONRPCResponseSchema"
 });
-var getJSONRPCResult = (response) => {
+var getJSONRPCResult = (response, operation, transport) => {
   if ("error" in response) {
-    const data = response.error.data === void 0 ? "" : `: ${JSON.stringify(response.error.data)}`;
-    throw new Error(
-      `Ogmios JSON-RPC error ${response.error.code}: ${response.error.message}${data}`
-    );
+    throw new OgmiosJsonRpcError({
+      code: response.error.code,
+      message: response.error.message,
+      data: response.error.data,
+      method: response.method,
+      id: response.id,
+      operation,
+      status: transport?.status,
+      retryAfterMs: retryAfterHeaderToMs(transport?.headers["retry-after"]),
+      cause: transport
+    });
+  }
+  if (transport && (transport.status < 200 || transport.status >= 300)) {
+    throw new KupmiosError({
+      protocol: "ogmios",
+      operation: operation ?? response.method ?? "unknown",
+      status: transport.status,
+      retryAfterMs: retryAfterHeaderToMs(transport.headers["retry-after"]),
+      cause: transport
+    });
   }
   return response.result;
 };
@@ -595,7 +735,7 @@ var LegacyDelegationSummarySchema = S.Struct({
   deposit: RewardAccountAdaSchema
 });
 var RewardAccountSummarySchema = S.Struct({
-  from: S.optional(S.Literal("key", "script")),
+  from: S.optional(S.Literal("key", "verificationKey", "script")),
   credential: S.optional(S.String),
   stakePool: S.optional(S.NullOr(S.Struct({ id: S.String }))),
   rewards: RewardAccountAdaSchema,
@@ -699,7 +839,17 @@ var ValueSchema = S2.Struct({
   coins: QuantitySchema,
   assets: S2.Record({ key: S2.String, value: QuantitySchema })
 });
-var UTxOSchema = S2.Struct({
+var PointSchema = S2.Struct({
+  slot_no: S2.Number,
+  header_hash: S2.String
+});
+var ScriptSchema = S2.NullOr(
+  S2.Struct({
+    language: S2.Literal("native", "plutus:v1", "plutus:v2", "plutus:v3"),
+    script: S2.String
+  })
+);
+var UTxOFields = {
   transaction_index: S2.Number,
   transaction_id: S2.String,
   output_index: S2.Number,
@@ -708,23 +858,15 @@ var UTxOSchema = S2.Struct({
   datum_hash: S2.NullOr(S2.String),
   datum_type: S2.optional(S2.Literal("hash", "inline")),
   script_hash: S2.NullOr(S2.String),
-  created_at: S2.Struct({
-    slot_no: S2.Number,
-    header_hash: S2.String
-  }),
-  spent_at: S2.NullOr(
-    S2.Struct({
-      slot_no: S2.Number,
-      header_hash: S2.String
-    })
-  )
+  created_at: PointSchema,
+  spent_at: S2.NullOr(PointSchema)
+};
+var UTxOSchema = S2.Struct(UTxOFields);
+var ResolvedUTxOSchema = S2.Struct({
+  ...UTxOFields,
+  datum: S2.NullOr(S2.String),
+  script: ScriptSchema
 });
-var ScriptSchema = S2.NullOr(
-  S2.Struct({
-    language: S2.Literal("native", "plutus:v1", "plutus:v2", "plutus:v3"),
-    script: S2.String
-  })
-);
 var DatumSchema = S2.NullOr(S2.Struct({ datum: S2.String }));
 var DelegationSchema = S2.NullOr(
   S2.Record({
@@ -791,6 +933,33 @@ var makePostAsJson = (url, data, schema, headers) => pipe2(
   // Prevents resource leaks and ensures clean request termination
   Effect.scoped
 );
+var makePostAsJsonResponse = (url, data, schema, headers) => pipe2(
+  HttpClientRequest.post(url),
+  headers ? HttpClientRequest.setHeaders(headers) : identity,
+  HttpClientRequest.bodyJson(data),
+  Effect.flatMap(HttpClient.execute),
+  Effect.flatMap(
+    (response) => pipe2(
+      HttpClientResponse.schemaBodyJson(schema)(response),
+      Effect.map((body) => ({
+        body,
+        status: response.status,
+        headers: response.headers
+      })),
+      Effect.catchAll(
+        (cause) => response.status >= 200 && response.status < 300 ? Effect.fail(cause) : Effect.fail(
+          new HttpClientError.ResponseError({
+            response,
+            request: response.request,
+            reason: "StatusCode",
+            description: "non 2xx status code with an invalid JSON response"
+          })
+        )
+      )
+    )
+  ),
+  Effect.scoped
+);
 var makePostAsUint8Array = (url, data, schema, headers) => pipe2(
   // Initiate a POST request to the specified URL
   HttpClientRequest.post(url),
@@ -812,19 +981,50 @@ var makePostAsUint8Array = (url, data, schema, headers) => pipe2(
 
 // src/kupmios.ts
 import { FetchHttpClient } from "@effect/platform";
-var KupmiosError = class extends Data.TaggedError("KupmiosError") {
-  get message() {
-    return `${this.cause}`;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_AWAIT_TX_TIMEOUT_MS = 16e4;
+var validateTimeout = (name, timeout) => {
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    throw new TypeError(`${name} must be a positive finite number.`);
   }
+  return timeout;
+};
+var catchProviderError = (protocol, operation) => (effect) => Effect2.catchAll(
+  effect,
+  (cause) => Effect2.fail(toKupmiosError(cause, protocol, operation))
+);
+var runProviderEffect = async (effect, protocol, operation, signal) => {
+  const exit = await Effect2.runPromiseExit(effect, { signal });
+  if (Exit.isSuccess(exit)) return exit.value;
+  if (signal?.aborted) {
+    throw new KupmiosError({
+      protocol,
+      operation,
+      kind: "aborted",
+      retryable: false,
+      cause: signal.reason ?? Cause.squash(exit.cause)
+    });
+  }
+  throw toKupmiosError(Cause.squash(exit.cause), protocol, operation);
 };
 var Kupmios = class {
   kupoUrl;
   ogmiosUrl;
-  headers;
-  constructor(kupoUrl, ogmiosUrl, headers) {
+  options;
+  requestTimeoutMs;
+  awaitTxTimeoutMs;
+  constructor(kupoUrl, ogmiosUrl, options = {}) {
     this.kupoUrl = kupoUrl;
     this.ogmiosUrl = ogmiosUrl;
-    this.headers = headers;
+    this.options = options;
+    this.requestTimeoutMs = validateTimeout(
+      "requestTimeoutMs",
+      options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS
+    );
+    this.awaitTxTimeoutMs = validateTimeout(
+      "awaitTxTimeoutMs",
+      options.awaitTxTimeoutMs ?? DEFAULT_AWAIT_TX_TIMEOUT_MS
+    );
   }
   async getProtocolParameters() {
     const data = {
@@ -836,19 +1036,26 @@ var Kupmios = class {
     const schema = JSONRPCResponseSchema(
       S3.Record({ key: S3.String, value: S3.Unknown })
     );
-    const response = await pipe3(
-      makePostAsJson(
-        this.ogmiosUrl,
-        data,
-        schema,
-        this.headers?.ogmiosHeader
+    const response = await runProviderEffect(
+      pipe3(
+        makePostAsJsonResponse(
+          this.ogmiosUrl,
+          data,
+          schema,
+          this.options.ogmiosHeader
+        ),
+        Effect2.timeout(this.requestTimeoutMs),
+        catchProviderError("ogmios", "queryLedgerState/protocolParameters"),
+        Effect2.provide(FetchHttpClient.layer)
       ),
-      Effect2.timeout(1e4),
-      Effect2.catchAll((cause) => new KupmiosError({ cause })),
-      Effect2.provide(FetchHttpClient.layer),
-      Effect2.runPromise
+      "ogmios",
+      "queryLedgerState/protocolParameters"
+    );
+    const result = getJSONRPCResult(
+      response.body,
+      data.method,
+      response
     );
-    const result = getJSONRPCResult(response);
     const protocolParameters = S3.decodeUnknownSync(
       ProtocolParametersSchema
     )(normalizeProtocolParameters(result));
@@ -864,35 +1071,43 @@ var Kupmios = class {
     const schema = JSONRPCResponseSchema(
       TreasuryAndReservesSchema
     );
-    const response = await pipe3(
-      makePostAsJson(
-        this.ogmiosUrl,
-        data,
-        schema,
-        this.headers?.ogmiosHeader
+    const response = await runProviderEffect(
+      pipe3(
+        makePostAsJsonResponse(
+          this.ogmiosUrl,
+          data,
+          schema,
+          this.options.ogmiosHeader
+        ),
+        Effect2.timeout(this.requestTimeoutMs),
+        catchProviderError("ogmios", "queryLedgerState/treasuryAndReserves"),
+        Effect2.provide(FetchHttpClient.layer)
       ),
-      Effect2.timeout(1e4),
-      Effect2.catchAll((cause) => new KupmiosError({ cause })),
-      Effect2.provide(FetchHttpClient.layer),
-      Effect2.runPromise
+      "ogmios",
+      "queryLedgerState/treasuryAndReserves"
+    );
+    const result = getJSONRPCResult(
+      response.body,
+      data.method,
+      response
     );
-    const result = getJSONRPCResult(response);
     return lovelaceAmountToBigInt(result.treasury.ada.lovelace);
   }
   async getUtxos(addressOrCredential) {
     const isAddress = typeof addressOrCredential === "string";
     const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
-    const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent`;
-    const schema = S3.Array(UTxOSchema);
-    const utxos = await pipe3(
-      makeGet(pattern, schema, this.headers?.kupoHeader),
-      Effect2.flatMap(
-        (u) => kupmiosUtxosToUtxos(this.kupoUrl, u, this.headers?.kupoHeader)
+    const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&resolve_hashes`;
+    const schema = S3.Array(ResolvedUTxOSchema);
+    const utxos = await runProviderEffect(
+      pipe3(
+        makeGet(pattern, schema, this.options.kupoHeader),
+        Effect2.map(kupmiosUtxosToUtxos),
+        Effect2.timeout(this.requestTimeoutMs),
+        catchProviderError("kupo", "getUtxos"),
+        Effect2.provide(FetchHttpClient.layer)
       ),
-      Effect2.timeout(1e4),
-      Effect2.catchAll((cause) => new KupmiosError({ cause })),
-      Effect2.provide(FetchHttpClient.layer),
-      Effect2.runPromise
+      "kupo",
+      "getUtxos"
     );
     return utxos;
   }
@@ -900,33 +1115,58 @@ var Kupmios = class {
     const isAddress = typeof addressOrCredential === "string";
     const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
     const { policyId, assetName } = fromUnit2(unit);
-    const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&policy_id=${policyId}${assetName ? `&asset_name=${assetName}` : ""}`;
-    const schema = S3.Array(UTxOSchema);
-    const utxos = await pipe3(
-      makeGet(pattern, schema, this.headers?.kupoHeader),
-      Effect2.flatMap(
-        (u) => kupmiosUtxosToUtxos(this.kupoUrl, u, this.headers?.kupoHeader)
+    const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&resolve_hashes&policy_id=${policyId}${assetName ? `&asset_name=${assetName}` : ""}`;
+    const schema = S3.Array(ResolvedUTxOSchema);
+    const utxos = await runProviderEffect(
+      pipe3(
+        makeGet(pattern, schema, this.options.kupoHeader),
+        Effect2.map(kupmiosUtxosToUtxos),
+        Effect2.timeout(this.requestTimeoutMs),
+        catchProviderError("kupo", "getUtxosWithUnit"),
+        Effect2.provide(FetchHttpClient.layer)
       ),
-      Effect2.timeout(1e4),
-      Effect2.catchAll((cause) => new KupmiosError({ cause })),
-      Effect2.provide(FetchHttpClient.layer),
-      Effect2.runPromise
+      "kupo",
+      "getUtxosWithUnit"
+    );
+    return utxos.filter((utxo) => (utxo.assets[unit] ?? 0n) > 0n);
+  }
+  async getUtxosWithPolicy(addressOrCredential, policyId) {
+    if (!/^[0-9a-f]{56}$/i.test(policyId)) {
+      throw new TypeError(
+        "policyId must be a 56-character hexadecimal string."
+      );
+    }
+    const normalizedPolicyId = policyId.toLowerCase();
+    const isAddress = typeof addressOrCredential === "string";
+    const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
+    const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&resolve_hashes&policy_id=${normalizedPolicyId}`;
+    const schema = S3.Array(ResolvedUTxOSchema);
+    return runProviderEffect(
+      pipe3(
+        makeGet(pattern, schema, this.options.kupoHeader),
+        Effect2.map(kupmiosUtxosToUtxos),
+        Effect2.timeout(this.requestTimeoutMs),
+        catchProviderError("kupo", "getUtxosWithPolicy"),
+        Effect2.provide(FetchHttpClient.layer)
+      ),
+      "kupo",
+      "getUtxosWithPolicy"
     );
-    return utxos;
   }
   async getUtxoByUnit(unit) {
     const { policyId, assetName } = fromUnit2(unit);
-    const pattern = `${this.kupoUrl}/matches/${policyId}.${assetName ? `${assetName}` : "*"}?unspent`;
-    const schema = S3.Array(UTxOSchema);
-    const utxos = await pipe3(
-      makeGet(pattern, schema, this.headers?.kupoHeader),
-      Effect2.flatMap(
-        (u) => kupmiosUtxosToUtxos(this.kupoUrl, u, this.headers?.kupoHeader)
+    const pattern = `${this.kupoUrl}/matches/${policyId}.${assetName ?? ""}?unspent&resolve_hashes`;
+    const schema = S3.Array(ResolvedUTxOSchema);
+    const utxos = await runProviderEffect(
+      pipe3(
+        makeGet(pattern, schema, this.options.kupoHeader),
+        Effect2.map(kupmiosUtxosToUtxos),
+        Effect2.timeout(this.requestTimeoutMs),
+        catchProviderError("kupo", "getUtxoByUnit"),
+        Effect2.provide(FetchHttpClient.layer)
       ),
-      Effect2.timeout(1e4),
-      Effect2.catchAll((cause) => new KupmiosError({ cause })),
-      Effect2.provide(FetchHttpClient.layer),
-      Effect2.runPromise
+      "kupo",
+      "getUtxoByUnit"
     );
     if (utxos.length === 0) {
       throw new Error("Unit not found.");
@@ -940,21 +1180,21 @@ var Kupmios = class {
     const queryHashes = [
       ...new Set(outRefs.map((outRef) => outRef.txHash))
     ];
-    const mkPattern = (txHash) => `${this.kupoUrl}/matches/*@${txHash}?unspent`;
-    const schema = S3.Array(UTxOSchema);
+    const mkPattern = (txHash) => `${this.kupoUrl}/matches/*@${txHash}?unspent&resolve_hashes`;
+    const schema = S3.Array(ResolvedUTxOSchema);
     const program = Effect2.forEach(
       queryHashes,
       (txHash) => pipe3(
-        makeGet(mkPattern(txHash), schema, this.headers?.kupoHeader),
-        Effect2.flatMap(
-          (u) => kupmiosUtxosToUtxos(this.kupoUrl, u, this.headers?.kupoHeader)
-        ),
-        Effect2.timeout(1e4),
-        Effect2.catchAll((cause) => new KupmiosError({ cause }))
+        makeGet(mkPattern(txHash), schema, this.options.kupoHeader),
+        Effect2.map(kupmiosUtxosToUtxos),
+        Effect2.timeout(this.requestTimeoutMs),
+        catchProviderError("kupo", "getUtxosByOutRef")
       )
     );
-    const utxos = await Effect2.runPromise(
-      pipe3(program, Effect2.provide(FetchHttpClient.layer))
+    const utxos = await runProviderEffect(
+      pipe3(program, Effect2.provide(FetchHttpClient.layer)),
+      "kupo",
+      "getUtxosByOutRef"
     );
     return _Array.flatten(utxos).filter(
       (utxo) => outRefs.some(
@@ -962,7 +1202,7 @@ var Kupmios = class {
       )
     );
   }
-  async getDelegation(rewardAddress) {
+  async getRewardAccount(rewardAddress) {
     const data = {
       jsonrpc: "2.0",
       method: "queryLedgerState/rewardAccountSummaries",
@@ -970,50 +1210,95 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCResponseSchema(Delegation);
-    const response = await pipe3(
-      makePostAsJson(
-        this.ogmiosUrl,
-        data,
-        schema,
-        this.headers?.ogmiosHeader
+    const response = await runProviderEffect(
+      pipe3(
+        makePostAsJsonResponse(
+          this.ogmiosUrl,
+          data,
+          schema,
+          this.options.ogmiosHeader
+        ),
+        Effect2.provide(FetchHttpClient.layer),
+        Effect2.timeout(this.requestTimeoutMs),
+        catchProviderError("ogmios", "queryLedgerState/rewardAccountSummaries")
       ),
-      Effect2.provide(FetchHttpClient.layer),
-      Effect2.timeout(1e4),
-      Effect2.catchAll((cause) => new KupmiosError({ cause })),
-      Effect2.runPromise
+      "ogmios",
+      "queryLedgerState/rewardAccountSummaries"
+    );
+    const result = getJSONRPCResult(
+      response.body,
+      data.method,
+      response
     );
-    const result = getJSONRPCResult(response);
-    return toDelegation(result);
+    return toRewardAccountState(result);
+  }
+  async getDelegation(rewardAddress) {
+    const { poolId, rewards } = await this.getRewardAccount(rewardAddress);
+    return { poolId, rewards };
   }
   async getDatum(datumHash) {
     const pattern = `${this.kupoUrl}/datums/${datumHash}`;
     const schema = DatumSchema;
-    const result = await pipe3(
-      makeGet(pattern, schema, this.headers?.kupoHeader),
-      Effect2.provide(FetchHttpClient.layer),
-      Effect2.timeout(1e4),
-      Effect2.flatMap(Effect2.fromNullable),
-      Effect2.catchAll((cause) => new KupmiosError({ cause })),
-      Effect2.runPromise
+    const result = await runProviderEffect(
+      pipe3(
+        makeGet(pattern, schema, this.options.kupoHeader),
+        Effect2.provide(FetchHttpClient.layer),
+        Effect2.timeout(this.requestTimeoutMs),
+        Effect2.flatMap(Effect2.fromNullable),
+        catchProviderError("kupo", "getDatum")
+      ),
+      "kupo",
+      "getDatum"
     );
     return result.datum;
   }
+  async getTransactionStatus(txHash, options = {}) {
+    const pattern = `${this.kupoUrl}/matches/*@${txHash}`;
+    const schema = S3.Array(UTxOSchema).annotations({
+      identifier: "Array<KupmiosSchema.KupoUTxO>"
+    });
+    const matches = await runProviderEffect(
+      pipe3(
+        makeGet(pattern, schema, this.options.kupoHeader),
+        Effect2.timeout(this.requestTimeoutMs),
+        catchProviderError("kupo", "getTransactionStatus"),
+        Effect2.provide(FetchHttpClient.layer)
+      ),
+      "kupo",
+      "getTransactionStatus",
+      options.signal
+    );
+    if (matches.length === 0) return { status: "not_found", txHash };
+    const createdAt = matches[0].created_at;
+    return {
+      status: "confirmed",
+      txHash,
+      confirmation: {
+        txHash,
+        blockHash: createdAt.header_hash,
+        slot: createdAt.slot_no
+      }
+    };
+  }
   async awaitTx(txHash, checkInterval = 2e4) {
-    const pattern = `${this.kupoUrl}/matches/*@${txHash}?unspent`;
+    const pattern = `${this.kupoUrl}/matches/*@${txHash}`;
     const schema = S3.Array(UTxOSchema).annotations({
       identifier: "Array<KupmiosSchema.KupoUTxO>"
     });
-    const result = await pipe3(
-      makeGet(pattern, schema, this.headers?.kupoHeader),
-      Effect2.provide(FetchHttpClient.layer),
-      Effect2.repeat({
-        schedule: Schedule.exponential(checkInterval),
-        until: (result2) => result2.length > 0
-      }),
-      Effect2.timeout(16e4),
-      Effect2.catchAll((cause) => new KupmiosError({ cause })),
-      Effect2.as(true),
-      Effect2.runPromise
+    const result = await runProviderEffect(
+      pipe3(
+        makeGet(pattern, schema, this.options.kupoHeader),
+        Effect2.provide(FetchHttpClient.layer),
+        Effect2.repeat({
+          schedule: Schedule.exponential(checkInterval),
+          until: (result2) => result2.length > 0
+        }),
+        Effect2.timeout(this.awaitTxTimeoutMs),
+        catchProviderError("kupo", "awaitTx"),
+        Effect2.as(true)
+      ),
+      "kupo",
+      "awaitTx"
     );
     return result;
   }
@@ -1033,19 +1318,26 @@ var Kupmios = class {
         })
       })
     );
-    const response = await pipe3(
-      makePostAsJson(
-        this.ogmiosUrl,
-        data,
-        schema,
-        this.headers?.ogmiosHeader
+    const response = await runProviderEffect(
+      pipe3(
+        makePostAsJsonResponse(
+          this.ogmiosUrl,
+          data,
+          schema,
+          this.options.ogmiosHeader
+        ),
+        Effect2.provide(FetchHttpClient.layer),
+        Effect2.timeout(this.requestTimeoutMs),
+        catchProviderError("ogmios", "submitTransaction")
       ),
-      Effect2.provide(FetchHttpClient.layer),
-      Effect2.timeout(1e4),
-      Effect2.catchAll((cause) => new KupmiosError({ cause })),
-      Effect2.runPromise
+      "ogmios",
+      "submitTransaction"
+    );
+    const result = getJSONRPCResult(
+      response.body,
+      data.method,
+      response
     );
-    const result = getJSONRPCResult(response);
     return result.transaction.id;
   }
   async evaluateTx(tx, additionalUTxOs) {
@@ -1059,19 +1351,26 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCResponseSchema(S3.Array(RedeemerSchema));
-    const response = await pipe3(
-      makePostAsJson(
-        this.ogmiosUrl,
-        data,
-        schema,
-        this.headers?.ogmiosHeader
+    const response = await runProviderEffect(
+      pipe3(
+        makePostAsJsonResponse(
+          this.ogmiosUrl,
+          data,
+          schema,
+          this.options.ogmiosHeader
+        ),
+        Effect2.provide(FetchHttpClient.layer),
+        Effect2.timeout(this.requestTimeoutMs),
+        catchProviderError("ogmios", "evaluateTransaction")
       ),
-      Effect2.provide(FetchHttpClient.layer),
-      Effect2.timeout(1e4),
-      Effect2.catchAll((cause) => new KupmiosError({ cause })),
-      Effect2.runPromise
+      "ogmios",
+      "evaluateTransaction"
+    );
+    const result = getJSONRPCResult(
+      response.body,
+      data.method,
+      response
     );
-    const result = getJSONRPCResult(response);
     const evalRedeemers = result.map((item) => ({
       ex_units: {
         mem: item.budget.memory,
@@ -1083,59 +1382,6 @@ var Kupmios = class {
     return evalRedeemers;
   }
 };
-var getDatumEffect = (kupoUrl, datum_type, datum_hash, kupoHeader) => Effect2.gen(function* () {
-  if (datum_type === "inline" && datum_hash) {
-    const pattern = `${kupoUrl}/datums/${datum_hash}`;
-    const schema = DatumSchema;
-    return yield* pipe3(
-      makeGet(pattern, schema, kupoHeader),
-      Effect2.flatMap(Effect2.fromNullable),
-      Effect2.map((result) => result.datum),
-      Effect2.retry(
-        Schedule.compose(Schedule.exponential(50), Schedule.recurs(5))
-      ),
-      Effect2.timeout(5e3)
-    );
-  } else return void 0;
-});
-var getScriptEffect = (kupoUrl, script_hash, kupoHeader) => Effect2.gen(function* () {
-  if (script_hash) {
-    const pattern = `${kupoUrl}/scripts/${script_hash}`;
-    const schema = ScriptSchema;
-    return yield* pipe3(
-      makeGet(pattern, schema, kupoHeader),
-      Effect2.flatMap(Effect2.fromNullable),
-      Effect2.retry(
-        Schedule.compose(Schedule.exponential(50), Schedule.recurs(5))
-      ),
-      Effect2.timeout(5e3),
-      Effect2.map(({ language, script }) => {
-        switch (language) {
-          case "native":
-            return {
-              type: "Native",
-              script
-            };
-          case "plutus:v1":
-            return {
-              type: "PlutusV1",
-              script: applyDoubleCborEncoding2(script)
-            };
-          case "plutus:v2":
-            return {
-              type: "PlutusV2",
-              script: applyDoubleCborEncoding2(script)
-            };
-          case "plutus:v3":
-            return {
-              type: "PlutusV3",
-              script: applyDoubleCborEncoding2(script)
-            };
-        }
-      })
-    );
-  } else return void 0;
-});
 var toAssets = (value) => {
   const assets = { lovelace: BigInt(value.coins) };
   for (const unit of Object.keys(value.assets)) {
@@ -1173,42 +1419,48 @@ var toProtocolParameters = (result) => {
     }
   };
 };
-var toDelegation = (result) => {
-  if (!result) {
-    return { poolId: null, rewards: 0n };
-  }
-  const delegation = Array.isArray(result) ? result[0] : Object.values(result)[0];
+var toRewardAccountState = (result) => {
+  const delegation = result ? Array.isArray(result) ? result[0] : Object.values(result)[0] : void 0;
   if (!delegation) {
-    return { poolId: null, rewards: 0n };
+    return { registered: false, poolId: null, rewards: 0n };
   }
   return {
+    registered: true,
     poolId: "stakePool" in delegation ? delegation.stakePool?.id || null : delegation.delegate?.id || null,
     rewards: BigInt(delegation.rewards.ada.lovelace)
   };
 };
-var kupmiosUtxosToUtxos = (kupoURL, utxos, kupoHeader) => Effect2.forEach(
-  utxos,
-  (utxo) => {
-    return pipe3(
-      Effect2.all([
-        getDatumEffect(kupoURL, utxo.datum_type, utxo.datum_hash, kupoHeader),
-        getScriptEffect(kupoURL, utxo.script_hash, kupoHeader)
-      ]),
-      Effect2.map(
-        ([datum, script]) => ({
-          txHash: utxo.transaction_id,
-          outputIndex: utxo.output_index,
-          address: utxo.address,
-          assets: toAssets(utxo.value),
-          datumHash: utxo.datum_type === "hash" ? utxo.datum_hash : void 0,
-          datum,
-          scriptRef: script
-        })
-      )
-    );
-  },
-  { concurrency: "unbounded" }
-);
+var toScriptRef = (script) => {
+  if (!script) return void 0;
+  switch (script.language) {
+    case "native":
+      return { type: "Native", script: script.script };
+    case "plutus:v1":
+      return {
+        type: "PlutusV1",
+        script: applyDoubleCborEncoding2(script.script)
+      };
+    case "plutus:v2":
+      return {
+        type: "PlutusV2",
+        script: applyDoubleCborEncoding2(script.script)
+      };
+    case "plutus:v3":
+      return {
+        type: "PlutusV3",
+        script: applyDoubleCborEncoding2(script.script)
+      };
+  }
+};
+var kupmiosUtxosToUtxos = (utxos) => utxos.map((utxo) => ({
+  txHash: utxo.transaction_id,
+  outputIndex: utxo.output_index,
+  address: utxo.address,
+  assets: toAssets(utxo.value),
+  datumHash: utxo.datum_type === "hash" ? utxo.datum_hash : void 0,
+  datum: utxo.datum_type === "inline" ? utxo.datum : void 0,
+  scriptRef: toScriptRef(utxo.script)
+}));
 
 // src/emulator.ts
 import {
@@ -1219,6 +1471,12 @@ import {
 import { coreToUtxo, getAddressDetails } from "@lucid-evolution/utils";
 import { fromHex as fromHex2 } from "@lucid-evolution/core-utils";
 import { walletFromSeed } from "@lucid-evolution/wallet";
+var EMULATOR_PROVIDER_BRAND = Symbol.for(
+  "@lucid-evolution/provider/Emulator"
+);
+var isEmulatorProvider = (provider) => Boolean(
+  provider && provider[EMULATOR_PROVIDER_BRAND]
+);
 function generateEmulatorAccountFromPrivateKey(assets) {
   const privateKey = CML.PrivateKey.generate_ed25519().to_bech32();
   const priv = CML.PrivateKey.from_bech32(privateKey);
@@ -1248,6 +1506,7 @@ function generateEmulatorAccount(assets) {
   };
 }
 var Emulator = class {
+  [EMULATOR_PROVIDER_BRAND] = true;
   ledger;
   mempool = {};
   /**
@@ -1261,6 +1520,7 @@ var Emulator = class {
   protocolParameters;
   datumTable = {};
   treasury;
+  transactionHistory = {};
   constructor(accounts, protocolParameters = PROTOCOL_PARAMETERS_DEFAULT, treasury = 0n) {
     const GENESIS_HASH = "00".repeat(32);
     this.blockHeight = 0;
@@ -1296,12 +1556,27 @@ var Emulator = class {
   now() {
     return this.time;
   }
+  confirmPendingTransactions(blockHeight, slot) {
+    for (const [txHash, status] of Object.entries(this.transactionHistory)) {
+      if (status.status === "pending") {
+        this.transactionHistory[txHash] = {
+          status: "confirmed",
+          blockHeight,
+          slot
+        };
+      }
+    }
+  }
   awaitSlot(length = 1) {
     this.slot += length;
     this.time += length * 1e3;
     const currentHeight = this.blockHeight;
     this.blockHeight = Math.floor(this.slot / 20);
     if (this.blockHeight > currentHeight) {
+      this.confirmPendingTransactions(
+        currentHeight + 1,
+        (currentHeight + 1) * 20
+      );
       for (const [outRef, { utxo, spent }] of Object.entries(this.mempool)) {
         this.ledger[outRef] = { utxo, spent };
       }
@@ -1312,9 +1587,14 @@ var Emulator = class {
     }
   }
   awaitBlock(height = 1) {
+    const previousHeight = this.blockHeight;
+    const previousSlot = this.slot;
     this.blockHeight += height;
     this.slot += height * 20;
     this.time += height * 20 * 1e3;
+    if (height > 0) {
+      this.confirmPendingTransactions(previousHeight + 1, previousSlot + 20);
+    }
     for (const [outRef, { utxo, spent }] of Object.entries(this.mempool)) {
       this.ledger[outRef] = { utxo, spent };
     }
@@ -1324,14 +1604,17 @@ var Emulator = class {
     this.mempool = {};
   }
   getUtxos(addressOrCredential) {
-    const utxos = Object.values(this.ledger).flatMap(({ utxo }) => {
-      if (typeof addressOrCredential === "string") {
-        return addressOrCredential === utxo.address ? utxo : [];
-      } else {
-        const { paymentCredential } = getAddressDetails(utxo.address);
-        return paymentCredential?.hash === addressOrCredential.hash ? utxo : [];
+    const utxos = Object.values(this.ledger).flatMap(
+      ({ utxo, spent }) => {
+        if (spent) return [];
+        if (typeof addressOrCredential === "string") {
+          return addressOrCredential === utxo.address ? utxo : [];
+        } else {
+          const { paymentCredential } = getAddressDetails(utxo.address);
+          return paymentCredential?.hash === addressOrCredential.hash ? utxo : [];
+        }
       }
-    });
+    );
     return Promise.resolve(utxos);
   }
   getProtocolParameters() {
@@ -1344,32 +1627,44 @@ var Emulator = class {
     return Promise.resolve(this.datumTable[datumHash]);
   }
   getUtxosWithUnit(addressOrCredential, unit) {
-    const utxos = Object.values(this.ledger).flatMap(({ utxo }) => {
-      if (typeof addressOrCredential === "string") {
-        return addressOrCredential === utxo.address && utxo.assets[unit] > 0n ? utxo : [];
-      } else {
-        const { paymentCredential } = getAddressDetails(utxo.address);
-        return paymentCredential?.hash === addressOrCredential.hash && utxo.assets[unit] > 0n ? utxo : [];
+    const utxos = Object.values(this.ledger).flatMap(
+      ({ utxo, spent }) => {
+        if (spent) return [];
+        if (typeof addressOrCredential === "string") {
+          return addressOrCredential === utxo.address && utxo.assets[unit] > 0n ? utxo : [];
+        } else {
+          const { paymentCredential } = getAddressDetails(utxo.address);
+          return paymentCredential?.hash === addressOrCredential.hash && utxo.assets[unit] > 0n ? utxo : [];
+        }
       }
-    });
+    );
     return Promise.resolve(utxos);
   }
   getUtxosByOutRef(outRefs) {
     return Promise.resolve(
-      outRefs.flatMap(
-        (outRef) => this.ledger[outRef.txHash + outRef.outputIndex]?.utxo || []
-      )
+      outRefs.flatMap((outRef) => {
+        const entry = this.ledger[outRef.txHash + outRef.outputIndex];
+        return entry && !entry.spent ? entry.utxo : [];
+      })
     );
   }
   getUtxoByUnit(unit) {
     const utxos = Object.values(this.ledger).flatMap(
-      ({ utxo }) => utxo.assets[unit] > 0n ? utxo : []
+      ({ utxo, spent }) => !spent && utxo.assets[unit] > 0n ? utxo : []
     );
     if (utxos.length > 1) {
       throw new Error("Unit needs to be an NFT or only held by one address.");
     }
     return Promise.resolve(utxos[0]);
   }
+  getRewardAccount(rewardAddress) {
+    const account = this.chain[rewardAddress];
+    return Promise.resolve({
+      registered: account?.registeredStake ?? false,
+      poolId: account?.delegation.poolId ?? null,
+      rewards: account?.delegation.rewards ?? 0n
+    });
+  }
   getDelegation(rewardAddress) {
     return Promise.resolve({
       poolId: this.chain[rewardAddress]?.delegation?.poolId || null,
@@ -1377,12 +1672,34 @@ var Emulator = class {
     });
   }
   awaitTx(txHash) {
-    if (this.mempool[txHash + 0]) {
+    if (this.transactionHistory[txHash]?.status === "pending") {
       this.awaitBlock();
       return Promise.resolve(true);
     }
     return Promise.resolve(true);
   }
+  getTransactionStatus(txHash, options = {}) {
+    if (options.signal?.aborted) {
+      return Promise.reject(
+        options.signal.reason instanceof Error ? options.signal.reason : new DOMException("The operation was aborted.", "AbortError")
+      );
+    }
+    const status = this.transactionHistory[txHash];
+    if (!status) return Promise.resolve({ status: "not_found", txHash });
+    if (status.status === "pending") {
+      return Promise.resolve({ status: "pending", txHash });
+    }
+    return Promise.resolve({
+      status: "confirmed",
+      txHash,
+      confirmation: {
+        txHash,
+        blockHeight: status.blockHeight,
+        slot: status.slot,
+        confirmations: this.blockHeight - status.blockHeight + 1
+      }
+    });
+  }
   /**
    * Emulates the behaviour of the reward distribution at epoch boundaries.
    * Stake keys need to be registered and delegated like on a real chain in order to receive rewards.
@@ -2063,6 +2380,7 @@ It does not exist or was already spent.`
     for (const [datumHash, datum] of Object.entries(datumTable)) {
       this.datumTable[datumHash] = datum;
     }
+    this.transactionHistory[txHash] = { status: "pending" };
     return Promise.resolve(txHash);
   }
   async evaluateTx(tx, additionalUTxOs) {
@@ -2318,21 +2636,30 @@ var Maestro = class {
     );
     return utxos.map(this.maestroUtxoToUtxo);
   }
-  async getDelegation(rewardAddress) {
-    const timestampedResultResponse = await fetch(
-      `${this.url}/accounts/${rewardAddress}`,
-      { headers: this.commonHeaders() }
-    );
-    if (!timestampedResultResponse.ok) {
-      return { poolId: null, rewards: 0n };
+  async getRewardAccount(rewardAddress) {
+    const response = await fetch(`${this.url}/accounts/${rewardAddress}`, {
+      headers: this.requireAmountsAsStrings(this.commonHeaders())
+    });
+    if (response.status === 404) {
+      return { registered: false, poolId: null, rewards: 0n };
     }
-    const timestampedResult = await timestampedResultResponse.json();
+    if (!response.ok) {
+      throw new Error(
+        `Could not fetch reward account from Maestro. Received status code: ${response.status}`
+      );
+    }
+    const timestampedResult = await response.json();
     const result = timestampedResult.data;
     return {
+      registered: result.registered,
       poolId: result.delegated_pool || null,
       rewards: BigInt(result.rewards_available)
     };
   }
+  async getDelegation(rewardAddress) {
+    const { poolId, rewards } = await this.getRewardAccount(rewardAddress);
+    return { poolId, rewards };
+  }
   async getDatum(datumHash) {
     const timestampedResultResponse = await fetch(
       `${this.url}/datums/${datumHash}`,
@@ -2370,6 +2697,42 @@ var Maestro = class {
       }, checkInterval);
     });
   }
+  async getTransactionStatus(txHash, options = {}) {
+    const response = await fetch(`${this.url}/txmanager/${txHash}/state`, {
+      headers: this.commonHeaders(),
+      signal: options.signal
+    });
+    if (response.status === 404) return { status: "not_found", txHash };
+    if (!response.ok) {
+      throw new Error(
+        `Could not fetch transaction status from Maestro. Received status code: ${response.status}`
+      );
+    }
+    const result = await response.json();
+    switch (result.status) {
+      case "pending":
+        return { status: "pending", txHash };
+      case "confirmed":
+        return {
+          status: "confirmed",
+          txHash,
+          confirmation: {
+            txHash,
+            confirmations: result.confirmations
+          }
+        };
+      case "failed":
+        return {
+          status: "failed",
+          txHash,
+          reason: result.reason ?? result.error
+        };
+      default:
+        throw new Error(
+          `Maestro returned an unknown transaction status: ${String(result.status)}`
+        );
+    }
+  }
   async submitTx(tx) {
     let queryUrl = `${this.url}/txmanager`;
     queryUrl += this.turboSubmit ? "/turbosubmit" : "";
@@ -2413,7 +2776,7 @@ var Maestro = class {
       address: result.address,
       datumHash: result.datum ? result.datum.type == "inline" ? void 0 : result.datum.hash : void 0,
       datum: result.datum?.bytes,
-      scriptRef: toScriptRef(result.reference_script)
+      scriptRef: toScriptRef2(result.reference_script)
     };
   }
   async getAllPagesData(getResponse, qry, paramsGiven, errorMsg) {
@@ -2464,7 +2827,7 @@ var Maestro = class {
     return result;
   }
 };
-var toScriptRef = (reference_script) => {
+var toScriptRef2 = (reference_script) => {
   if (reference_script && reference_script.bytes) {
     switch (reference_script.type) {
       case "native":
@@ -2719,8 +3082,13 @@ var AssetAddressSchema = S4.Struct({
   quantity: S4.String
 });
 var AccountInfoSchema = S4.Struct({
+  status: S4.Literal("registered", "not registered"),
   delegated_pool: S4.NullOr(S4.String),
-  rewards_available: S4.NumberFromString
+  rewards_available: S4.String
+});
+var TxStatusSchema = S4.Struct({
+  tx_hash: S4.String,
+  num_confirmations: S4.NullOr(S4.Number)
 });
 var DatumInfo = S4.Struct({
   bytes: S4.String
@@ -2741,9 +3109,9 @@ var toUTxO = (koiosUTxO, address) => ({
   address,
   datumHash: koiosUTxO.inline_datum ? void 0 : koiosUTxO.datum_hash || void 0,
   datum: koiosUTxO.inline_datum ? koiosUTxO.inline_datum.bytes : void 0,
-  scriptRef: toScriptRef2(koiosUTxO.reference_script)
+  scriptRef: toScriptRef3(koiosUTxO.reference_script)
 });
-var toScriptRef2 = (reference_script) => {
+var toScriptRef3 = (reference_script) => {
   if (reference_script && reference_script.bytes && reference_script.type) {
     switch (reference_script.type) {
       case "plutusV1":
@@ -2786,9 +3154,9 @@ var getUtxosEffect = (baseUrl, addressOrCredential, headers) => {
 };
 
 // src/koios.ts
-import { Data as Data2, Effect as Effect4, pipe as pipe5, Schedule as Schedule2, Schema as S5 } from "effect";
+import { Data, Effect as Effect4, pipe as pipe5, Schedule as Schedule2, Schema as S5 } from "effect";
 import { FetchHttpClient as FetchHttpClient3 } from "@effect/platform";
-var KoiosError = class extends Data2.TaggedError("KoiosError") {
+var KoiosError = class extends Data.TaggedError("KoiosError") {
   get message() {
     return `${this.cause}`;
   }
@@ -2957,7 +3325,7 @@ var Koios = class {
       return [];
     }
   }
-  async getDelegation(rewardAddress) {
+  async getRewardAccount(rewardAddress) {
     const body = {
       _stake_addresses: [rewardAddress]
     };
@@ -2972,18 +3340,24 @@ var Koios = class {
       ),
       // Allows for dependency injection and easier testing
       Effect4.provide(FetchHttpClient3.layer),
-      Effect4.flatMap(
-        (result2) => result2.length === 0 ? Effect4.fail("No Delegation Found by Reward Address") : Effect4.succeed(result2[0])
-      ),
       Effect4.timeout(1e4),
       Effect4.catchAllCause((cause) => new KoiosError({ cause })),
       Effect4.runPromise
     );
+    const account = result[0];
+    if (!account) {
+      return { registered: false, poolId: null, rewards: 0n };
+    }
     return {
-      poolId: result.delegated_pool || null,
-      rewards: BigInt(result.rewards_available)
+      registered: account.status === "registered",
+      poolId: account.delegated_pool || null,
+      rewards: BigInt(account.rewards_available)
     };
   }
+  async getDelegation(rewardAddress) {
+    const { poolId, rewards } = await this.getRewardAccount(rewardAddress);
+    return { poolId, rewards };
+  }
   async getDatum(datumHash) {
     const url = `${this.baseUrl}/datum_info`;
     const body = {
@@ -3030,6 +3404,38 @@ var Koios = class {
     );
     return result;
   }
+  async getTransactionStatus(txHash, options = {}) {
+    const url = `${this.baseUrl}/tx_status`;
+    const body = { _tx_hashes: [txHash] };
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...bearerToken },
+      body: JSON.stringify(body),
+      signal: options.signal
+    });
+    if (response.status === 404) return { status: "not_found", txHash };
+    if (!response.ok) {
+      throw new Error(
+        `Could not fetch transaction status from Koios. Received status code: ${response.status}`
+      );
+    }
+    const result = S5.decodeUnknownSync(S5.Array(TxStatusSchema))(
+      await response.json()
+    );
+    const status = result[0];
+    if (!status || status.num_confirmations === null) {
+      return { status: "not_found", txHash };
+    }
+    return {
+      status: "confirmed",
+      txHash,
+      confirmation: {
+        txHash,
+        confirmations: status.num_confirmations
+      }
+    };
+  }
   async submitTx(tx) {
     const url = `${this.baseUrl}/submittx`;
     const body = fromHex4(tx);
@@ -3085,6 +3491,8 @@ export {
   Kupmios,
   KupmiosError,
   Maestro,
+  OgmiosJsonRpcError,
   generateEmulatorAccount,
-  generateEmulatorAccountFromPrivateKey
+  generateEmulatorAccountFromPrivateKey,
+  isEmulatorProvider
 };