@lucid-evolution/provider 0.1.96 → 0.2.0

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.96",
+  version: "0.2.0",
   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;
 };
@@ -486,6 +626,28 @@ var TupleNumberFromString = S.compose(
   S.split("/"),
   S.Array(S.NumberFromString)
 );
+var MaxReferenceScriptsSizeSchema = S.Struct({
+  bytes: S.Number
+});
+function normalizeProtocolParameters(value) {
+  const legacy = value.maxReferenceScriptsSize;
+  const current = value.maxReferenceScriptsSizePerTransaction;
+  if (legacy === void 0 && current === void 0) {
+    return value;
+  }
+  const decode = S.decodeUnknownSync(MaxReferenceScriptsSizeSchema);
+  const legacyValue = legacy === void 0 ? void 0 : decode(legacy);
+  const currentValue = current === void 0 ? void 0 : decode(current);
+  if (legacyValue !== void 0 && currentValue !== void 0 && legacyValue.bytes !== currentValue.bytes) {
+    throw new Error(
+      "Conflicting Ogmios protocol parameters: maxReferenceScriptsSize and maxReferenceScriptsSizePerTransaction differ"
+    );
+  }
+  return {
+    ...value,
+    maxReferenceScriptsSize: legacyValue ?? currentValue
+  };
+}
 var ProtocolParametersSchema = S.Struct({
   minFeeCoefficient: S.Number,
   minFeeReferenceScripts: S.Struct({
@@ -493,9 +655,7 @@ var ProtocolParametersSchema = S.Struct({
     range: S.Number,
     multiplier: S.Number
   }),
-  maxReferenceScriptsSize: S.Struct({
-    bytes: S.Number
-  }),
+  maxReferenceScriptsSize: MaxReferenceScriptsSizeSchema,
   stakePoolVotingThresholds: S.Struct({
     noConfidence: TupleNumberFromString,
     constitutionalCommittee: S.Struct({
@@ -575,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,
@@ -771,6 +931,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),
@@ -792,10 +979,23 @@ 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 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;
@@ -814,22 +1014,32 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCResponseSchema(
-      ProtocolParametersSchema
+      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.headers?.ogmiosHeader
+        ),
+        Effect2.timeout(1e4),
+        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);
-    return toProtocolParameters(result);
+    const protocolParameters = S3.decodeUnknownSync(
+      ProtocolParametersSchema
+    )(normalizeProtocolParameters(result));
+    return toProtocolParameters(protocolParameters);
   }
   async getTreasury() {
     const data = {
@@ -841,19 +1051,26 @@ 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.headers?.ogmiosHeader
+        ),
+        Effect2.timeout(1e4),
+        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) {
@@ -861,15 +1078,18 @@ var Kupmios = class {
     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 utxos = await runProviderEffect(
+      pipe3(
+        makeGet(pattern, schema, this.headers?.kupoHeader),
+        Effect2.flatMap(
+          (u) => kupmiosUtxosToUtxos(this.kupoUrl, u, this.headers?.kupoHeader)
+        ),
+        Effect2.timeout(1e4),
+        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;
   }
@@ -879,31 +1099,62 @@ var Kupmios = class {
     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 utxos = await runProviderEffect(
+      pipe3(
+        makeGet(pattern, schema, this.headers?.kupoHeader),
+        Effect2.flatMap(
+          (u) => kupmiosUtxosToUtxos(this.kupoUrl, u, this.headers?.kupoHeader)
+        ),
+        Effect2.timeout(1e4),
+        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&policy_id=${normalizedPolicyId}`;
+    const schema = S3.Array(UTxOSchema);
+    return runProviderEffect(
+      pipe3(
+        makeGet(pattern, schema, this.headers?.kupoHeader),
+        Effect2.flatMap(
+          (utxos) => kupmiosUtxosToUtxos(this.kupoUrl, utxos, this.headers?.kupoHeader)
+        ),
+        Effect2.timeout(1e4),
+        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 pattern = `${this.kupoUrl}/matches/${policyId}.${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 utxos = await runProviderEffect(
+      pipe3(
+        makeGet(pattern, schema, this.headers?.kupoHeader),
+        Effect2.flatMap(
+          (u) => kupmiosUtxosToUtxos(this.kupoUrl, u, this.headers?.kupoHeader)
+        ),
+        Effect2.timeout(1e4),
+        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.");
@@ -927,11 +1178,13 @@ var Kupmios = class {
           (u) => kupmiosUtxosToUtxos(this.kupoUrl, u, this.headers?.kupoHeader)
         ),
         Effect2.timeout(1e4),
-        Effect2.catchAll((cause) => new KupmiosError({ cause }))
+        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(
@@ -939,7 +1192,7 @@ var Kupmios = class {
       )
     );
   }
-  async getDelegation(rewardAddress) {
+  async getRewardAccount(rewardAddress) {
     const data = {
       jsonrpc: "2.0",
       method: "queryLedgerState/rewardAccountSummaries",
@@ -947,50 +1200,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.headers?.ogmiosHeader
+        ),
+        Effect2.provide(FetchHttpClient.layer),
+        Effect2.timeout(1e4),
+        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);
-    return toDelegation(result);
+    const result = getJSONRPCResult(
+      response.body,
+      data.method,
+      response
+    );
+    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.headers?.kupoHeader),
+        Effect2.provide(FetchHttpClient.layer),
+        Effect2.timeout(1e4),
+        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.headers?.kupoHeader),
+        Effect2.timeout(1e4),
+        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.headers?.kupoHeader),
+        Effect2.provide(FetchHttpClient.layer),
+        Effect2.repeat({
+          schedule: Schedule.exponential(checkInterval),
+          until: (result2) => result2.length > 0
+        }),
+        Effect2.timeout(16e4),
+        catchProviderError("kupo", "awaitTx"),
+        Effect2.as(true)
+      ),
+      "kupo",
+      "awaitTx"
     );
     return result;
   }
@@ -1010,19 +1308,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.headers?.ogmiosHeader
+        ),
+        Effect2.provide(FetchHttpClient.layer),
+        Effect2.timeout(1e4),
+        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) {
@@ -1036,19 +1341,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.headers?.ogmiosHeader
+        ),
+        Effect2.provide(FetchHttpClient.layer),
+        Effect2.timeout(1e4),
+        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,
@@ -1150,15 +1462,13 @@ 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)
   };
@@ -1196,6 +1506,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);
@@ -1225,6 +1541,7 @@ function generateEmulatorAccount(assets) {
   };
 }
 var Emulator = class {
+  [EMULATOR_PROVIDER_BRAND] = true;
   ledger;
   mempool = {};
   /**
@@ -1238,6 +1555,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;
@@ -1273,12 +1591,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 };
       }
@@ -1289,9 +1622,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 };
     }
@@ -1301,14 +1639,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() {
@@ -1321,32 +1662,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,
@@ -1354,12 +1707,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.
@@ -2040,6 +2415,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) {
@@ -2295,21 +2671,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}`,
@@ -2347,6 +2732,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" : "";
@@ -2696,8 +3117,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
@@ -2763,9 +3189,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}`;
   }
@@ -2934,7 +3360,7 @@ var Koios = class {
       return [];
     }
   }
-  async getDelegation(rewardAddress) {
+  async getRewardAccount(rewardAddress) {
     const body = {
       _stake_addresses: [rewardAddress]
     };
@@ -2949,18 +3375,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 = {
@@ -3007,6 +3439,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);
@@ -3062,6 +3526,8 @@ export {
   Kupmios,
   KupmiosError,
   Maestro,
+  OgmiosJsonRpcError,
   generateEmulatorAccount,
-  generateEmulatorAccountFromPrivateKey
+  generateEmulatorAccountFromPrivateKey,
+  isEmulatorProvider
 };