@lucid-evolution/provider 0.1.45 → 0.1.46

package/dist/index.js

@@ -1,20 +1,14 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // src/core.ts
 import * as CML from "@anastasia-labs/cardano-multiplatform-lib-nodejs";
 
-// src/blockfrost/blockfrost.ts
+// src/blockfrost.ts
 import { fromHex, sleep } from "@lucid-evolution/core-utils";
 import { applyDoubleCborEncoding } from "@lucid-evolution/utils";
 
 // package.json
 var package_default = {
   name: "@lucid-evolution/provider",
-  version: "0.1.45",
+  version: "0.1.46",
   description: "",
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
@@ -62,8 +56,48 @@ var package_default = {
   }
 };
 
-// src/blockfrost/blockfrost.ts
+// src/internal/blockfrost.ts
 import { pipe, Record } from "effect";
+var toAditionalUTXOs = (utxos) => (utxos || []).map((utxo) => [
+  {
+    txId: utxo.txHash,
+    index: utxo.outputIndex
+  },
+  {
+    address: utxo.address,
+    value: {
+      coins: Number(utxo.assets["lovelace"]),
+      assets: fromAssets(utxo.assets)
+    },
+    datumHash: utxo.datumHash,
+    datum: utxo.datum,
+    script: toTxOutScript(utxo.scriptRef)
+  }
+]);
+var toTxOutScript = (scriptRef) => {
+  if (scriptRef) {
+    switch (scriptRef.type) {
+      case "PlutusV1":
+        return { "plutus:v1": scriptRef.script };
+      case "PlutusV2":
+        return { "plutus:v2": scriptRef.script };
+      case "PlutusV3":
+        return { "plutus:v3": scriptRef.script };
+      default:
+        return void 0;
+    }
+  }
+};
+var fromAssets = (assets) => pipe(
+  Record.remove(assets, "lovelace"),
+  Record.mapEntries((amount, unit) => [
+    unit.length === 56 ? unit.slice(0, 56) : unit.slice(0, 56) + "." + unit.slice(56),
+    Number(amount)
+  ]),
+  (r) => Record.isEmptyRecord(r) ? void 0 : r
+);
+
+// src/blockfrost.ts
 var Blockfrost = class {
   url;
   projectId;
@@ -341,42 +375,6 @@ var Blockfrost = class {
     return evalRedeemers;
   }
 };
-function datumJsonToCbor(json) {
-  const convert = (json2) => {
-    if (!isNaN(json2.int)) {
-      return CML.PlutusData.new_integer(
-        CML.BigInteger.from_str(json2.int.toString())
-      );
-    } else if (json2.bytes || !isNaN(Number(json2.bytes))) {
-      return CML.PlutusData.new_bytes(fromHex(json2.bytes));
-    } else if (json2.map) {
-      const m = CML.PlutusMap.new();
-      json2.map.forEach(({ k, v }) => {
-        m.set(convert(k), convert(v));
-      });
-      return CML.PlutusData.new_map(m);
-    } else if (json2.list) {
-      const l = CML.PlutusDataList.new();
-      json2.list.forEach((v) => {
-        l.add(convert(v));
-      });
-      return CML.PlutusData.new_list(l);
-    } else if (!isNaN(json2.constructor)) {
-      const l = CML.PlutusDataList.new();
-      json2.fields.forEach((v) => {
-        l.add(convert(v));
-      });
-      return CML.PlutusData.new_constr_plutus_data(
-        CML.ConstrPlutusData.new(
-          CML.BigInteger.from_str(json2.constructor.toString()).as_u64(),
-          l
-        )
-      );
-    }
-    throw new Error("Unsupported type");
-  };
-  return convert(json).to_cbor_hex();
-}
 var handleRateLimit = async (count) => {
   if (count % 100 === 0) {
     await sleep(5e3);
@@ -385,52 +383,21 @@ var handleRateLimit = async (count) => {
   }
 };
 var lucid = package_default.version;
-var toAditionalUTXOs = (utxos) => (utxos || []).map((utxo) => [
-  {
-    txId: utxo.txHash,
-    index: utxo.outputIndex
-  },
-  {
-    address: utxo.address,
-    value: {
-      coins: Number(utxo.assets["lovelace"]),
-      assets: fromAssets(utxo.assets)
-    },
-    datumHash: utxo.datumHash,
-    datum: utxo.datum,
-    script: toTxOutScript(utxo.scriptRef)
-  }
-]);
-var toTxOutScript = (scriptRef) => {
-  if (scriptRef) {
-    switch (scriptRef.type) {
-      case "PlutusV1":
-        return { "plutus:v1": scriptRef.script };
-      case "PlutusV2":
-        return { "plutus:v2": scriptRef.script };
-      case "PlutusV3":
-        return { "plutus:v3": scriptRef.script };
-      default:
-        return void 0;
-    }
-  }
-};
-var fromAssets = (assets) => pipe(
-  Record.remove(assets, "lovelace"),
-  Record.mapEntries((amount, unit) => [
-    unit.length === 56 ? unit.slice(0, 56) : unit.slice(0, 56) + "." + unit.slice(56),
-    Number(amount)
-  ]),
-  (r) => Record.isEmptyRecord(r) ? void 0 : r
-);
 
-// src/kupmios/kupmios.ts
-import { applyDoubleCborEncoding as applyDoubleCborEncoding2, fromUnit } from "@lucid-evolution/utils";
-import * as S2 from "@effect/schema/Schema";
+// src/kupmios.ts
+import { applyDoubleCborEncoding as applyDoubleCborEncoding2, fromUnit as fromUnit2 } from "@lucid-evolution/utils";
+import * as S3 from "@effect/schema/Schema";
 import { Effect, pipe as pipe2, Array as _Array, Schedule, Data } from "effect";
+import {
+  HttpClient,
+  HttpClientRequest,
+  HttpClientResponse
+} from "@effect/platform";
+import { ArrayFormatter } from "@effect/schema";
 
-// src/kupmios/schema.ts
+// src/internal/ogmios.ts
 import * as S from "@effect/schema/Schema";
+import { fromUnit } from "@lucid-evolution/utils";
 var JSONRPCSchema = (schema) => S.extend(
   S.Struct({
     jsonrpc: S.String,
@@ -526,63 +493,118 @@ var ProtocolParametersSchema = S.Struct({
   maxCollateralInputs: S.Number,
   version: S.Struct({ major: S.Number, minor: S.Number })
 });
-var KupoValueSchema = S.Struct({
-  coins: S.Number,
-  assets: S.Record(S.String, S.Number)
+var Delegation = S.NullOr(
+  S.Record(
+    S.String,
+    S.Struct({
+      delegate: S.Struct({ id: S.String }),
+      rewards: S.Struct({ ada: S.Struct({ lovelace: S.Number }) }),
+      deposit: S.Struct({ ada: S.Struct({ lovelace: S.Number }) })
+    })
+  )
+);
+var RedeemerSchema = S.Struct({
+  validator: S.Struct({
+    purpose: S.String,
+    index: S.Int
+  }),
+  budget: S.Struct({
+    memory: S.Int,
+    cpu: S.Int
+  })
+});
+var toOgmiosUTxOs = (utxos) => {
+  const toOgmiosScript = (scriptRef) => {
+    if (scriptRef) {
+      switch (scriptRef.type) {
+        case "PlutusV1":
+          return { language: "plutus:v1", cbor: scriptRef.script };
+        case "PlutusV2":
+          return { language: "plutus:v2", cbor: scriptRef.script };
+        case "PlutusV3":
+          return { language: "plutus:v3", cbor: scriptRef.script };
+        default:
+          return null;
+      }
+    }
+  };
+  const toOgmiosAssets = (assets) => {
+    const newAssets = {};
+    Object.entries(assets).map(([unit, amount]) => {
+      if (unit == "lovelace") return;
+      const { policyId, assetName } = fromUnit(unit);
+      newAssets[policyId][assetName ? assetName : ""] = Number(amount);
+    });
+    return newAssets;
+  };
+  return (utxos || []).map(
+    (utxo) => ({
+      transaction: {
+        id: utxo.txHash
+      },
+      index: utxo.outputIndex,
+      address: utxo.address,
+      value: {
+        ada: { lovelace: Number(utxo.assets["lovelace"]) },
+        ...toOgmiosAssets(utxo.assets)
+      },
+      datumHash: utxo.datumHash,
+      datum: utxo.datum,
+      script: toOgmiosScript(utxo.scriptRef)
+    })
+  );
+};
+
+// src/internal/kupo.ts
+import * as S2 from "@effect/schema/Schema";
+var ValueSchema = S2.Struct({
+  coins: S2.Number,
+  assets: S2.Record(S2.String, S2.Number)
 });
-var KupoUTxO = S.Struct({
-  transaction_index: S.Number,
-  transaction_id: S.String,
-  output_index: S.Number,
-  address: S.String,
-  value: KupoValueSchema,
-  datum_hash: S.NullOr(S.String),
-  datum_type: S.optional(S.Literal("hash", "inline")),
-  script_hash: S.NullOr(S.String),
-  created_at: S.Struct({
-    slot_no: S.Number,
-    header_hash: S.String
+var UTxOSchema = S2.Struct({
+  transaction_index: S2.Number,
+  transaction_id: S2.String,
+  output_index: S2.Number,
+  address: S2.String,
+  value: ValueSchema,
+  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: S.NullOr(
-    S.Struct({
-      slot_no: S.Number,
-      header_hash: S.String
+  spent_at: S2.NullOr(
+    S2.Struct({
+      slot_no: S2.Number,
+      header_hash: S2.String
     })
   )
 });
-var KupoScriptSchema = S.NullOr(
-  S.Struct({
-    language: S.Literal("native", "plutus:v1", "plutus:v2", "plutus:v3"),
-    script: S.String
+var ScriptSchema = S2.NullOr(
+  S2.Struct({
+    language: S2.Literal("native", "plutus:v1", "plutus:v2", "plutus:v3"),
+    script: S2.String
   })
 );
-var KupoDatumSchema = S.NullOr(S.Struct({ datum: S.String }));
-var KupoDelegation = S.NullOr(
-  S.Record(
-    S.String,
-    S.Struct({
-      delegate: S.Struct({ id: S.String }),
-      rewards: S.Struct({ ada: S.Struct({ lovelace: S.Number }) }),
-      deposit: S.Struct({ ada: S.Struct({ lovelace: S.Number }) })
+var DatumSchema = S2.NullOr(S2.Struct({ datum: S2.String }));
+var DelegationSchema = S2.NullOr(
+  S2.Record(
+    S2.String,
+    S2.Struct({
+      delegate: S2.Struct({ id: S2.String }),
+      rewards: S2.Struct({ ada: S2.Struct({ lovelace: S2.Number }) }),
+      deposit: S2.Struct({ ada: S2.Struct({ lovelace: S2.Number }) })
     })
   )
 );
 
-// src/kupmios/kupmios.ts
-import {
-  HttpClient,
-  HttpClientRequest,
-  HttpClientResponse
-} from "@effect/platform";
-import { ArrayFormatter } from "@effect/schema";
+// src/kupmios.ts
 var KupmiosError = class extends Data.TaggedError("KupmiosError") {
   get message() {
-    return `${this.cause}`;
+    return `${JSON.stringify(this.cause)}`;
   }
 };
-var kupmiosError = (cause) => new KupmiosError({
-  cause: JSON.stringify(cause)
-});
 var Kupmios = class {
   kupoUrl;
   ogmiosUrl;
@@ -601,15 +623,13 @@ var Kupmios = class {
       params: {},
       id: null
     };
-    const schema = JSONRPCSchema(
-      ProtocolParametersSchema
-    );
+    const schema = JSONRPCSchema(ProtocolParametersSchema);
     const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
       Effect.flatMap(
-        (response) => "error" in response ? kupmiosError(response.error) : Effect.succeed(response.result)
+        (response) => "error" in response ? Effect.fail(response) : Effect.succeed(response.result)
       ),
       Effect.timeout(1e4),
-      Effect.catchAll(kupmiosError)
+      Effect.catchAll((cause) => new KupmiosError({ cause }))
     );
     const result = await Effect.runPromise(program);
     return toProtocolParameters(result);
@@ -618,11 +638,11 @@ var Kupmios = class {
     const isAddress = typeof addressOrCredential === "string";
     const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
     const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent`;
-    const schema = S2.Array(KupoUTxO);
+    const schema = S3.Array(UTxOSchema);
     const program = fetchKupoParse(pattern, schema).pipe(
       Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
       Effect.timeout(1e4),
-      Effect.catchAll(kupmiosError)
+      Effect.catchAll((cause) => new KupmiosError({ cause }))
     );
     const utxos = await Effect.runPromise(program);
     return utxos;
@@ -630,25 +650,25 @@ var Kupmios = class {
   async getUtxosWithUnit(addressOrCredential, unit) {
     const isAddress = typeof addressOrCredential === "string";
     const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
-    const { policyId, assetName } = fromUnit(unit);
+    const { policyId, assetName } = fromUnit2(unit);
     const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&policy_id=${policyId}${assetName ? `&asset_name=${assetName}` : ""}`;
-    const schema = S2.Array(KupoUTxO);
+    const schema = S3.Array(UTxOSchema);
     const program = fetchKupoParse(pattern, schema).pipe(
       Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
       Effect.timeout(1e4),
-      Effect.catchAll(kupmiosError)
+      Effect.catchAll((cause) => new KupmiosError({ cause }))
     );
     const utxos = await Effect.runPromise(program);
     return utxos;
   }
   async getUtxoByUnit(unit) {
-    const { policyId, assetName } = fromUnit(unit);
+    const { policyId, assetName } = fromUnit2(unit);
     const pattern = `${this.kupoUrl}/matches/${policyId}.${assetName ? `${assetName}` : "*"}?unspent`;
-    const schema = S2.Array(KupoUTxO);
+    const schema = S3.Array(UTxOSchema);
     const program = fetchKupoParse(pattern, schema).pipe(
       Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
       Effect.timeout(1e4),
-      Effect.catchAll(kupmiosError)
+      Effect.catchAll((cause) => new KupmiosError({ cause }))
     );
     const utxos = await Effect.runPromise(program);
     if (utxos.length > 1) {
@@ -661,13 +681,13 @@ var Kupmios = class {
       ...new Set(outRefs.map((outRef) => outRef.txHash))
     ];
     const mkPattern = (txHash) => `${this.kupoUrl}/matches/*@${txHash}?unspent`;
-    const schema = S2.Array(KupoUTxO);
+    const schema = S3.Array(UTxOSchema);
     const program = Effect.forEach(
       queryHashes,
       (txHash) => fetchKupoParse(mkPattern(txHash), schema).pipe(
         Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
         Effect.timeout(1e4),
-        Effect.catchAll(kupmiosError)
+        Effect.catchAll((cause) => new KupmiosError({ cause }))
       )
     );
     const utxos = await Effect.runPromise(program);
@@ -684,13 +704,13 @@ var Kupmios = class {
       params: { keys: [rewardAddress] },
       id: null
     };
-    const schema = JSONRPCSchema(KupoDelegation);
+    const schema = JSONRPCSchema(Delegation);
     const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
       Effect.flatMap(
-        (response) => "error" in response ? kupmiosError(response.error) : Effect.succeed(response.result)
+        (response) => "error" in response ? Effect.fail(response) : Effect.succeed(response.result)
       ),
       Effect.timeout(1e4),
-      Effect.catchAll(kupmiosError)
+      Effect.catchAll((cause) => new KupmiosError({ cause }))
     );
     const result = await Effect.runPromise(program);
     const delegation = result ? Object.values(result)[0] : null;
@@ -701,18 +721,18 @@ var Kupmios = class {
   }
   async getDatum(datumHash) {
     const pattern = `${this.kupoUrl}/datums/${datumHash}`;
-    const schema = KupoDatumSchema;
+    const schema = DatumSchema;
     const program = fetchKupoParse(pattern, schema).pipe(
       Effect.timeout(1e4),
       Effect.flatMap(Effect.fromNullable),
-      Effect.catchAll(kupmiosError)
+      Effect.catchAll((cause) => new KupmiosError({ cause }))
     );
     const result = await Effect.runPromise(program);
     return result.datum;
   }
   async awaitTx(txHash, checkInterval = 2e4) {
     const pattern = `${this.kupoUrl}/matches/*@${txHash}`;
-    const schema = S2.Array(KupoUTxO).annotations({
+    const schema = S3.Array(UTxOSchema).annotations({
       identifier: "Array<KupmiosSchema.KupoUTxO>"
     });
     const program = fetchKupoParse(pattern, schema).pipe(
@@ -721,7 +741,7 @@ var Kupmios = class {
         until: (result) => result.length > 0
       }),
       Effect.timeout(16e4),
-      Effect.catchAll(kupmiosError),
+      Effect.catchAll((cause) => new KupmiosError({ cause })),
       Effect.as(true)
     );
     return await Effect.runPromise(program);
@@ -736,70 +756,39 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCSchema(
-      S2.Struct({
-        transaction: S2.Struct({
-          id: S2.String
+      S3.Struct({
+        transaction: S3.Struct({
+          id: S3.String
         })
       })
     );
     const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
       Effect.flatMap(
-        (response) => "error" in response ? Effect.fail(response.error) : Effect.succeed(response)
+        (response) => "error" in response ? Effect.fail(response) : Effect.succeed(response)
       ),
       Effect.timeout(1e4),
-      Effect.catchAll(kupmiosError)
+      Effect.catchAll((cause) => new KupmiosError({ cause }))
     );
     const { result } = await Effect.runPromise(program);
     return result.transaction.id;
   }
   async evaluateTx(tx, additionalUTxOs) {
-    const utxos = (additionalUTxOs || []).map((utxo) => {
-      const script = utxo.scriptRef ? {
-        language: utxo.scriptRef.type,
-        cbor: utxo.scriptRef.script
-      } : void 0;
-      return [
-        {
-          transaction: { id: utxo.txHash, output: { index: utxo.outputIndex } }
-        },
-        {
-          address: utxo.address,
-          value: {
-            coins: utxo.assets.lovelace,
-            assets: utxo.assets.restAssets
-          },
-          datumHash: utxo.datumHash,
-          datum: utxo.datum,
-          script
-        }
-      ];
-    });
     const data = {
       jsonrpc: "2.0",
       method: "evaluateTransaction",
-      params: { transaction: { cbor: tx }, additionalUTxO: utxos },
+      params: {
+        transaction: { cbor: tx },
+        additionalUtxo: toOgmiosUTxOs(additionalUTxOs)
+      },
       id: null
     };
-    const schema = JSONRPCSchema(
-      S2.Array(
-        S2.Struct({
-          validator: S2.Struct({
-            purpose: S2.String,
-            index: S2.Int
-          }),
-          budget: S2.Struct({
-            memory: S2.Int,
-            cpu: S2.Int
-          })
-        })
-      )
-    );
+    const schema = JSONRPCSchema(S3.Array(RedeemerSchema));
     const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
       Effect.flatMap(
-        (response) => "error" in response ? kupmiosError(response.error) : Effect.succeed(response.result)
+        (response) => "error" in response ? Effect.fail(response) : Effect.succeed(response.result)
       ),
       Effect.timeout(1e4),
-      Effect.catchAll(kupmiosError)
+      Effect.catchAll((cause) => new KupmiosError({ cause }))
     );
     const result = await Effect.runPromise(program);
     const evalRedeemers = result.map((item) => ({
@@ -816,7 +805,7 @@ var Kupmios = class {
 var getDatumEffect = (kupoUrl, datum_type, datum_hash) => Effect.gen(function* () {
   if (datum_type === "inline" && datum_hash) {
     const pattern = `${kupoUrl}/datums/${datum_hash}`;
-    const schema = KupoDatumSchema;
+    const schema = DatumSchema;
     return yield* fetchKupoParse(pattern, schema).pipe(
       Effect.flatMap(Effect.fromNullable),
       Effect.map((result) => result.datum),
@@ -827,7 +816,7 @@ var getDatumEffect = (kupoUrl, datum_type, datum_hash) => Effect.gen(function* (
 var getScriptEffect = (kupoUrl, script_hash) => Effect.gen(function* () {
   if (script_hash) {
     const pattern = `${kupoUrl}/scripts/${script_hash}`;
-    const schema = KupoScriptSchema;
+    const schema = ScriptSchema;
     return yield* pipe2(
       fetchKupoParse(pattern, schema),
       Effect.flatMap(Effect.fromNullable),
@@ -846,6 +835,11 @@ var getScriptEffect = (kupoUrl, script_hash) => Effect.gen(function* () {
               type: "PlutusV2",
               script: applyDoubleCborEncoding2(script)
             };
+          case "plutus:v3":
+            return {
+              type: "PlutusV3",
+              script: applyDoubleCborEncoding2(script)
+            };
         }
       })
     );
@@ -905,9 +899,7 @@ var fetchOgmiosParse = (url, data, schema) => pipe2(
   HttpClientRequest.jsonBody(data),
   Effect.flatMap(HttpClient.fetch),
   HttpClientResponse.json,
-  Effect.flatMap(
-    S2.decodeUnknown(schema, { onExcessProperty: "error", errors: "first" })
-  ),
+  Effect.flatMap(S3.decodeUnknown(schema, { onExcessProperty: "error" })),
   Effect.catchTag(
     "ParseError",
     (e) => Effect.fail(ArrayFormatter.formatErrorSync(e))
@@ -918,7 +910,7 @@ var fetchKupoParse = (url, schema) => pipe2(
   HttpClientRequest.get(url),
   HttpClient.fetchOk,
   HttpClientResponse.json,
-  Effect.flatMap(S2.decodeUnknown(schema, { onExcessProperty: "error" })),
+  Effect.flatMap(S3.decodeUnknown(schema, { onExcessProperty: "error" })),
   Effect.catchTag(
     "ParseError",
     (e) => Effect.fail(ArrayFormatter.formatErrorSync(e))
@@ -1949,13 +1941,13 @@ var Maestro = class {
   }
   async evaluateTx(tx, additionalUTxOs) {
     const additionalMaestroUTxOs = (additionalUTxOs || []).map((utxo) => ({
-      index: utxo.outputIndex,
       tx_hash: utxo.txHash,
-      tx_cbor: utxoToCore(utxo).to_cbor_hex
+      index: utxo.outputIndex,
+      txout_cbor: utxoToCore(utxo).output().to_cbor_hex()
     }));
     const payload = {
       cbor: tx,
-      additionalMaestroUTxOs
+      additional_utxos: additionalMaestroUTxOs
     };
     const res = await fetch(`${this.url}/transactions/evaluate`, {
       method: "POST",
@@ -2000,211 +1992,218 @@ var toScriptRef = (reference_script) => {
 };
 var lucid2 = package_default.version;
 
-// src/koios/koios.ts
-import * as S4 from "@effect/schema/Schema";
+// src/koios.ts
+import * as S5 from "@effect/schema/Schema";
 import { fromHex as fromHex4 } from "@lucid-evolution/core-utils";
-import { applyDoubleCborEncoding as applyDoubleCborEncoding4, fromUnit as fromUnit2 } from "@lucid-evolution/utils";
+import { fromUnit as fromUnit3 } from "@lucid-evolution/utils";
 
-// src/koios/schema.ts
-import * as S3 from "@effect/schema/Schema";
-var ProtocolParametersSchema2 = S3.Struct({
-  pvt_motion_no_confidence: S3.Number,
-  pvt_committee_normal: S3.Number,
-  pvt_committee_no_confidence: S3.Number,
-  pvt_hard_fork_initiation: S3.Number,
-  pvtpp_security_group: S3.Number,
-  dvt_motion_no_confidence: S3.Number,
-  dvt_committee_normal: S3.Number,
-  dvt_committee_no_confidence: S3.Number,
-  dvt_update_to_constitution: S3.Number,
-  dvt_hard_fork_initiation: S3.Number,
-  dvt_p_p_network_group: S3.Number,
-  dvt_p_p_economic_group: S3.Number,
-  dvt_p_p_technical_group: S3.Number,
-  dvt_p_p_gov_group: S3.Number,
-  dvt_treasury_withdrawal: S3.Number,
-  committee_min_size: S3.Number,
-  committee_max_term_length: S3.Number,
-  gov_action_lifetime: S3.Number,
-  gov_action_deposit: S3.NumberFromString,
-  drep_deposit: S3.NumberFromString,
-  drep_activity: S3.Number,
-  min_fee_ref_script_cost_per_byte: S3.Number,
-  epoch_no: S3.Number,
-  min_fee_a: S3.Number,
-  min_fee_b: S3.Number,
-  max_block_size: S3.Number,
-  max_tx_size: S3.Number,
-  max_bh_size: S3.Number,
-  key_deposit: S3.BigInt,
-  pool_deposit: S3.BigInt,
-  max_epoch: S3.Number,
-  optimal_pool_count: S3.Number,
-  influence: S3.Number,
-  monetary_expand_rate: S3.Number,
-  treasury_growth_rate: S3.Number,
-  decentralisation: S3.Number,
-  extra_entropy: S3.NullOr(S3.String),
-  protocol_major: S3.Number,
-  protocol_minor: S3.Number,
-  min_utxo_value: S3.String,
-  min_pool_cost: S3.String,
-  nonce: S3.String,
-  block_hash: S3.NullOr(S3.String),
-  cost_models: S3.Struct({
-    PlutusV1: S3.Array(S3.Number),
-    PlutusV2: S3.Array(S3.Number),
-    PlutusV3: S3.Array(S3.Number)
+// src/internal/koios.ts
+import {
+  HttpClient as HttpClient2,
+  HttpClientRequest as HttpClientRequest2,
+  HttpClientResponse as HttpClientResponse2
+} from "@effect/platform";
+import * as S4 from "@effect/schema/Schema";
+import { Effect as Effect2, pipe as pipe3 } from "effect";
+import { applyDoubleCborEncoding as applyDoubleCborEncoding4 } from "@lucid-evolution/utils";
+var ProtocolParametersSchema2 = S4.Struct({
+  pvt_motion_no_confidence: S4.Number,
+  pvt_committee_normal: S4.Number,
+  pvt_committee_no_confidence: S4.Number,
+  pvt_hard_fork_initiation: S4.Number,
+  pvtpp_security_group: S4.Number,
+  dvt_motion_no_confidence: S4.Number,
+  dvt_committee_normal: S4.Number,
+  dvt_committee_no_confidence: S4.Number,
+  dvt_update_to_constitution: S4.Number,
+  dvt_hard_fork_initiation: S4.Number,
+  dvt_p_p_network_group: S4.Number,
+  dvt_p_p_economic_group: S4.Number,
+  dvt_p_p_technical_group: S4.Number,
+  dvt_p_p_gov_group: S4.Number,
+  dvt_treasury_withdrawal: S4.Number,
+  committee_min_size: S4.Number,
+  committee_max_term_length: S4.Number,
+  gov_action_lifetime: S4.Number,
+  gov_action_deposit: S4.NumberFromString,
+  drep_deposit: S4.NumberFromString,
+  drep_activity: S4.Number,
+  min_fee_ref_script_cost_per_byte: S4.Number,
+  epoch_no: S4.Number,
+  min_fee_a: S4.Number,
+  min_fee_b: S4.Number,
+  max_block_size: S4.Number,
+  max_tx_size: S4.Number,
+  max_bh_size: S4.Number,
+  key_deposit: S4.BigInt,
+  pool_deposit: S4.BigInt,
+  max_epoch: S4.Number,
+  optimal_pool_count: S4.Number,
+  influence: S4.Number,
+  monetary_expand_rate: S4.Number,
+  treasury_growth_rate: S4.Number,
+  decentralisation: S4.Number,
+  extra_entropy: S4.NullOr(S4.String),
+  protocol_major: S4.Number,
+  protocol_minor: S4.Number,
+  min_utxo_value: S4.String,
+  min_pool_cost: S4.String,
+  nonce: S4.String,
+  block_hash: S4.NullOr(S4.String),
+  cost_models: S4.Struct({
+    PlutusV1: S4.Array(S4.Number),
+    PlutusV2: S4.Array(S4.Number),
+    PlutusV3: S4.Array(S4.Number)
   }),
-  price_mem: S3.Number,
-  price_step: S3.Number,
-  max_tx_ex_mem: S3.BigIntFromNumber,
-  max_tx_ex_steps: S3.BigIntFromNumber,
-  max_block_ex_mem: S3.Number,
-  max_block_ex_steps: S3.Number,
-  max_val_size: S3.Number,
-  collateral_percent: S3.Number,
-  max_collateral_inputs: S3.Number,
-  coins_per_utxo_size: S3.BigInt
+  price_mem: S4.Number,
+  price_step: S4.Number,
+  max_tx_ex_mem: S4.BigIntFromNumber,
+  max_tx_ex_steps: S4.BigIntFromNumber,
+  max_block_ex_mem: S4.Number,
+  max_block_ex_steps: S4.Number,
+  max_val_size: S4.Number,
+  collateral_percent: S4.Number,
+  max_collateral_inputs: S4.Number,
+  coins_per_utxo_size: S4.BigInt
 });
-var KoiosAssetSchema = S3.Struct({
-  policy_id: S3.String,
-  asset_name: S3.NullOr(S3.String),
-  fingerprint: S3.String,
-  decimals: S3.Number,
-  quantity: S3.String
+var AssetSchema = S4.Struct({
+  policy_id: S4.String,
+  asset_name: S4.NullOr(S4.String),
+  fingerprint: S4.String,
+  decimals: S4.Number,
+  quantity: S4.String
 });
-var ReferenceScriptSchema = S3.Struct({
-  hash: S3.NullOr(S3.String),
-  size: S3.NullOr(S3.Number),
-  type: S3.NullOr(S3.String),
-  bytes: S3.NullOr(S3.String),
-  value: S3.NullOr(S3.Object)
+var ReferenceScriptSchema = S4.Struct({
+  hash: S4.NullOr(S4.String),
+  size: S4.NullOr(S4.Number),
+  type: S4.NullOr(S4.String),
+  bytes: S4.NullOr(S4.String),
+  value: S4.NullOr(S4.Object)
 });
-var KoiosUTxOSchema = S3.Struct({
-  tx_hash: S3.String,
-  tx_index: S3.Number,
-  block_time: S3.Number,
-  block_height: S3.NullOr(S3.Number),
-  value: S3.String,
-  datum_hash: S3.NullOr(S3.String),
-  inline_datum: S3.NullOr(
-    S3.Struct({
-      bytes: S3.String,
-      value: S3.Object
+var UTxOSchema2 = S4.Struct({
+  tx_hash: S4.String,
+  tx_index: S4.Number,
+  block_time: S4.Number,
+  block_height: S4.NullOr(S4.Number),
+  value: S4.String,
+  datum_hash: S4.NullOr(S4.String),
+  inline_datum: S4.NullOr(
+    S4.Struct({
+      bytes: S4.String,
+      value: S4.Object
     })
   ),
-  reference_script: S3.NullOr(ReferenceScriptSchema),
-  asset_list: S3.NullOr(S3.Array(KoiosAssetSchema))
+  reference_script: S4.NullOr(ReferenceScriptSchema),
+  asset_list: S4.NullOr(S4.Array(AssetSchema))
 });
-var KoiosAddressInfoSchema = S3.Array(
-  S3.NullishOr(
-    S3.Struct({
-      address: S3.String,
-      balance: S3.String,
-      stake_address: S3.NullOr(S3.String),
-      script_address: S3.Boolean,
-      utxo_set: S3.Array(KoiosUTxOSchema)
+var AddressInfoSchema = S4.Array(
+  S4.NullishOr(
+    S4.Struct({
+      address: S4.String,
+      balance: S4.String,
+      stake_address: S4.NullOr(S4.String),
+      script_address: S4.Boolean,
+      utxo_set: S4.Array(UTxOSchema2)
     })
   )
 );
-var KoiosInputOutputSchema = S3.Struct({
-  payment_addr: S3.Struct({
-    bech32: S3.String,
-    cred: S3.String
+var InputOutputSchema = S4.Struct({
+  payment_addr: S4.Struct({
+    bech32: S4.String,
+    cred: S4.String
   }),
-  stake_addr: S3.NullOr(S3.String),
-  tx_hash: S3.String,
-  tx_index: S3.Number,
-  value: S3.String,
-  datum_hash: S3.NullOr(S3.String),
-  inline_datum: S3.NullOr(
-    S3.Struct({
-      bytes: S3.String,
-      value: S3.Object
+  stake_addr: S4.NullOr(S4.String),
+  tx_hash: S4.String,
+  tx_index: S4.Number,
+  value: S4.String,
+  datum_hash: S4.NullOr(S4.String),
+  inline_datum: S4.NullOr(
+    S4.Struct({
+      bytes: S4.String,
+      value: S4.Object
     })
   ),
-  reference_script: S3.NullOr(ReferenceScriptSchema),
-  asset_list: S3.Array(KoiosAssetSchema)
+  reference_script: S4.NullOr(ReferenceScriptSchema),
+  asset_list: S4.Array(AssetSchema)
 });
-var KoiosTxInfoSchema = S3.Struct({
-  tx_hash: S3.String,
-  block_hash: S3.String,
-  block_height: S3.Number,
-  epoch_no: S3.Number,
-  epoch_slot: S3.Number,
-  absolute_slot: S3.Number,
-  tx_timestamp: S3.Number,
-  tx_block_index: S3.Number,
-  tx_size: S3.Number,
-  total_output: S3.String,
-  fee: S3.String,
-  treasury_donation: S3.String,
-  deposit: S3.String,
-  invalid_before: S3.NullOr(S3.String),
-  invalid_after: S3.NullOr(S3.String),
-  collateral_inputs: S3.NullOr(S3.Array(KoiosInputOutputSchema)),
-  collateral_output: S3.NullOr(KoiosInputOutputSchema),
-  reference_inputs: S3.NullOr(S3.Array(KoiosInputOutputSchema)),
-  inputs: S3.Array(KoiosInputOutputSchema),
-  outputs: S3.Array(KoiosInputOutputSchema),
-  withdrawals: S3.NullOr(
-    S3.Array(
-      S3.Struct({
-        amount: S3.String,
-        stake_addr: S3.String
+var TxInfoSchema = S4.Struct({
+  tx_hash: S4.String,
+  block_hash: S4.String,
+  block_height: S4.Number,
+  epoch_no: S4.Number,
+  epoch_slot: S4.Number,
+  absolute_slot: S4.Number,
+  tx_timestamp: S4.Number,
+  tx_block_index: S4.Number,
+  tx_size: S4.Number,
+  total_output: S4.String,
+  fee: S4.String,
+  treasury_donation: S4.String,
+  deposit: S4.String,
+  invalid_before: S4.NullOr(S4.String),
+  invalid_after: S4.NullOr(S4.String),
+  collateral_inputs: S4.NullOr(S4.Array(InputOutputSchema)),
+  collateral_output: S4.NullOr(InputOutputSchema),
+  reference_inputs: S4.NullOr(S4.Array(InputOutputSchema)),
+  inputs: S4.Array(InputOutputSchema),
+  outputs: S4.Array(InputOutputSchema),
+  withdrawals: S4.NullOr(
+    S4.Array(
+      S4.Struct({
+        amount: S4.String,
+        stake_addr: S4.String
       })
     )
   ),
-  assets_minted: S3.NullOr(S3.Array(KoiosAssetSchema)),
-  metadata: S3.NullOr(S3.Object),
-  certificates: S3.NullOr(
-    S3.Array(
-      S3.Struct({
-        index: S3.Number,
-        type: S3.String,
-        info: S3.NullOr(S3.Object)
+  assets_minted: S4.NullOr(S4.Array(AssetSchema)),
+  metadata: S4.NullOr(S4.Object),
+  certificates: S4.NullOr(
+    S4.Array(
+      S4.Struct({
+        index: S4.Number,
+        type: S4.String,
+        info: S4.NullOr(S4.Object)
       })
     )
   ),
-  native_scripts: S3.NullOr(
-    S3.Array(
-      S3.Struct({
-        script_hash: S3.String,
-        script_json: S3.Object
+  native_scripts: S4.NullOr(
+    S4.Array(
+      S4.Struct({
+        script_hash: S4.String,
+        script_json: S4.Object
       })
     )
   ),
-  plutus_contracts: S3.NullOr(
-    S3.Array(
-      S3.Struct({
-        address: S3.String,
-        spends_input: S3.NullOr(
-          S3.Struct({
-            tx_hash: S3.String,
-            tx_index: S3.Number
+  plutus_contracts: S4.NullOr(
+    S4.Array(
+      S4.Struct({
+        address: S4.String,
+        spends_input: S4.NullOr(
+          S4.Struct({
+            tx_hash: S4.String,
+            tx_index: S4.Number
           })
         ),
-        script_hash: S3.String,
-        bytecode: S3.String,
-        size: S3.Number,
-        valid_contract: S3.Boolean,
-        input: S3.Struct({
-          redeemer: S3.Struct({
-            purpose: S3.Literal("spend", "mint", "cert", "reward"),
-            fee: S3.String,
-            unit: S3.Struct({
-              steps: S3.String,
-              mem: S3.String
+        script_hash: S4.String,
+        bytecode: S4.String,
+        size: S4.Number,
+        valid_contract: S4.Boolean,
+        input: S4.Struct({
+          redeemer: S4.Struct({
+            purpose: S4.Literal("spend", "mint", "cert", "reward"),
+            fee: S4.String,
+            unit: S4.Struct({
+              steps: S4.String,
+              mem: S4.String
             }),
-            datum: S3.Struct({
-              hash: S3.NullOr(S3.String),
-              value: S3.NullOr(S3.Object)
+            datum: S4.Struct({
+              hash: S4.NullOr(S4.String),
+              value: S4.NullOr(S4.Object)
             })
           }),
-          datum: S3.Struct({
-            hash: S3.NullOr(S3.String),
-            value: S3.NullOr(S3.Object)
+          datum: S4.Struct({
+            hash: S4.NullOr(S4.String),
+            value: S4.NullOr(S4.Object)
           })
         })
       })
@@ -2212,101 +2211,147 @@ var KoiosTxInfoSchema = S3.Struct({
   ),
   //TODO: add S.Struct
   // https://preprod.koios.rest/#post-/tx_info
-  voting_procedures: S3.Array(S3.Object),
+  voting_procedures: S4.Array(S4.Object),
   //TODO: add S.Struct
   // https://preprod.koios.rest/#post-/tx_info
-  proposal_procedures: S3.Object
+  proposal_procedures: S4.Object
 });
-
-// src/koios/koios.ts
-import { Effect as Effect3, pipe as pipe4, Schedule as Schedule2 } from "effect";
-import { ArrayFormatter as ArrayFormatter2 } from "@effect/schema";
-
-// src/fetch.ts
-var fetch_exports = {};
-__export(fetch_exports, {
-  FetchError: () => FetchError,
-  JsonError: () => JsonError,
-  ResponseError: () => ResponseError,
-  fetchEffect: () => fetchEffect
+var TxHashSchema = S4.String;
+var AssetAddressSchema = S4.Struct({
+  payment_address: S4.String,
+  stake_address: S4.NullOr(S4.String),
+  quantity: S4.String
 });
-import { Data as Data2, Effect as Effect2, pipe as pipe3 } from "effect";
-var FetchError = class extends Data2.TaggedError("FetchError") {
-};
-var ResponseError = class extends Data2.TaggedError("ResponseError") {
+var AccountInfoSchema = S4.Struct({
+  delegated_pool: S4.NullOr(S4.String),
+  rewards_available: S4.NumberFromString
+});
+var DatumInfo = S4.Struct({
+  bytes: S4.String
+});
+var postWithSchemaValidation = (url, data, schema) => pipe3(
+  HttpClientRequest2.post(url),
+  HttpClientRequest2.jsonBody(data),
+  Effect2.flatMap(HttpClient2.fetchOk),
+  HttpClientResponse2.json,
+  Effect2.flatMap(S4.decodeUnknown(schema))
+  // Effect.scoped
+);
+var getWithSchemaValidation = (url, schema) => pipe3(
+  HttpClientRequest2.get(url),
+  HttpClient2.fetchOk,
+  HttpClientResponse2.json,
+  Effect2.flatMap(S4.decodeUnknown(schema))
+);
+var toUTxO = (koiosUTxO, address) => ({
+  txHash: koiosUTxO.tx_hash,
+  outputIndex: koiosUTxO.tx_index,
+  assets: (() => {
+    const a = {};
+    if (koiosUTxO.asset_list) {
+      koiosUTxO.asset_list.forEach((am) => {
+        a[am.policy_id + am.asset_name] = BigInt(am.quantity);
+      });
+    }
+    a["lovelace"] = BigInt(koiosUTxO.value);
+    return a;
+  })(),
+  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)
+});
+var toScriptRef2 = (reference_script) => {
+  if (reference_script && reference_script.bytes && reference_script.type) {
+    switch (reference_script.type) {
+      case "plutusV1":
+        return {
+          type: "PlutusV1",
+          script: applyDoubleCborEncoding4(reference_script.bytes)
+        };
+      case "plutusV2":
+        return {
+          type: "PlutusV2",
+          script: applyDoubleCborEncoding4(reference_script.bytes)
+        };
+      case "plutusV3":
+        return {
+          type: "PlutusV3",
+          script: applyDoubleCborEncoding4(reference_script.bytes)
+        };
+      default:
+        return void 0;
+    }
+  }
 };
-var JsonError = class extends Data2.TaggedError("JsonError") {
+var getUtxosEffect = (baseUrl, addressOrCredential) => {
+  const url = `${baseUrl}/address_info`;
+  const body = {
+    _addresses: [addressOrCredential]
+  };
+  const schema = AddressInfoSchema;
+  const result = pipe3(
+    Effect2.if(typeof addressOrCredential === "string", {
+      onFalse: () => Effect2.fail("Credential Type is not supported in Koios yet."),
+      onTrue: () => postWithSchemaValidation(url, body, schema)
+    }),
+    Effect2.map(
+      ([result2]) => result2 ? result2.utxo_set.map((koiosUtxo) => toUTxO(koiosUtxo, result2.address)) : []
+    )
+  );
+  return result;
 };
-var fetchEffect = (input, requestInit) => pipe3(
-  Effect2.tryPromise({
-    try: () => fetch(input, requestInit),
-    catch: (error) => new FetchError({
-      message: `${String(error)}. Please ensure the server is operational or check the validity of the input:${input}.`
-    })
-  }),
-  Effect2.flatMap(
-    (response) => !response.ok ? new ResponseError({
-      message: `${response.status} ${response.statusText}`
-    }) : Effect2.succeed(response)
-  ),
-  Effect2.flatMap(
-    (response) => Effect2.tryPromise({
-      try: () => response.json(),
-      catch: (error) => new JsonError({ message: String(error) })
-    })
-  )
-);
 
-// src/koios/koios.ts
+// src/koios.ts
+import { Data as Data2, Effect as Effect3, pipe as pipe4, Schedule as Schedule2 } from "effect";
+var KoiosError = class extends Data2.TaggedError("KoiosError") {
+  get message() {
+    return `${this.cause}`;
+  }
+};
 var Koios = class {
   baseUrl;
   constructor(baseUrl) {
     this.baseUrl = baseUrl;
   }
   async getProtocolParameters() {
-    const result = await fetch(`${this.baseUrl}/epoch_params?limit=1`).then(
-      (res) => res.json()
-    );
-    const param = await pipe4(
-      S4.decodeUnknown(ProtocolParametersSchema2, {
-        onExcessProperty: "error",
-        errors: "first"
-      })(result[0]),
-      Effect3.catchTag(
-        "ParseError",
-        (e) => Effect3.fail(ArrayFormatter2.formatErrorSync(e))
-      ),
+    const url = `${this.baseUrl}/epoch_params?limit=1`;
+    const schema = S5.Array(ProtocolParametersSchema2);
+    const [result] = await pipe4(
+      getWithSchemaValidation(url, schema),
+      Effect3.timeout(1e4),
+      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
       Effect3.runPromise
     );
     return {
-      minFeeA: param.min_fee_a,
-      minFeeB: param.min_fee_b,
-      maxTxSize: param.max_tx_size,
-      maxValSize: param.max_val_size,
-      keyDeposit: param.key_deposit,
-      poolDeposit: param.pool_deposit,
-      priceMem: param.price_mem,
-      priceStep: param.price_step,
-      maxTxExMem: param.max_tx_ex_mem,
-      maxTxExSteps: param.max_tx_ex_steps,
-      coinsPerUtxoByte: param.coins_per_utxo_size,
-      collateralPercentage: param.collateral_percent,
-      maxCollateralInputs: param.max_collateral_inputs,
+      minFeeA: result.min_fee_a,
+      minFeeB: result.min_fee_b,
+      maxTxSize: result.max_tx_size,
+      maxValSize: result.max_val_size,
+      keyDeposit: result.key_deposit,
+      poolDeposit: result.pool_deposit,
+      priceMem: result.price_mem,
+      priceStep: result.price_step,
+      maxTxExMem: result.max_tx_ex_mem,
+      maxTxExSteps: result.max_tx_ex_steps,
+      coinsPerUtxoByte: result.coins_per_utxo_size,
+      collateralPercentage: result.collateral_percent,
+      maxCollateralInputs: result.max_collateral_inputs,
       costModels: {
         PlutusV1: Object.fromEntries(
-          param.cost_models.PlutusV1.map((value, index) => [
+          result.cost_models.PlutusV1.map((value, index) => [
             index.toString(),
             value
           ])
         ),
         PlutusV2: Object.fromEntries(
-          param.cost_models.PlutusV2.map((value, index) => [
+          result.cost_models.PlutusV2.map((value, index) => [
             index.toString(),
             value
           ])
         ),
         PlutusV3: Object.fromEntries(
-          param.cost_models.PlutusV3.map((value, index) => [
+          result.cost_models.PlutusV3.map((value, index) => [
             index.toString(),
             value
           ])
@@ -2315,109 +2360,80 @@ var Koios = class {
     };
   }
   async getUtxos(addressOrCredential) {
-    if (typeof addressOrCredential === "string") {
-      const body = {
-        _addresses: [addressOrCredential]
-      };
-      const result = await fetch(`${this.baseUrl}/address_info`, {
-        headers: {
-          Accept: "application/json",
-          "Content-Type": "application/json"
-        },
-        method: "POST",
-        body: JSON.stringify(body)
-      }).then((res) => res.json());
-      const [parsedResult] = await pipe4(
-        S4.decodeUnknown(KoiosAddressInfoSchema, {
-          onExcessProperty: "error",
-          errors: "first"
-        })(result),
-        Effect3.catchTag(
-          "ParseError",
-          (e) => Effect3.fail(ArrayFormatter2.formatErrorSync(e))
-        ),
-        Effect3.runPromise
-      );
-      return parsedResult ? parsedResult.utxo_set.map(
-        (koiosUTXO) => toUTxO(koiosUTXO, parsedResult.address)
-      ) : [];
-    } else {
-      throw Error("getUtxos by Credential Type is not supported in Koios yet.");
-    }
+    const result = await pipe4(
+      getUtxosEffect(this.baseUrl, addressOrCredential),
+      Effect3.timeout(1e4),
+      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect3.runPromise
+    );
+    return result;
   }
   async getUtxosWithUnit(addressOrCredential, unit) {
-    if (typeof addressOrCredential === "string") {
-      const utxos = await this.getUtxos(addressOrCredential);
-      if (utxos && utxos.length > 0) {
-        return utxos.filter((utxo) => {
+    const result = await pipe4(
+      getUtxosEffect(this.baseUrl, addressOrCredential),
+      Effect3.map(
+        (utxos) => utxos.filter((utxo) => {
           const keys = Object.keys(utxo.assets);
           return keys.length > 0 && keys.includes(unit);
-        });
-      } else {
-        return [];
-      }
-    } else {
-      throw Error(
-        "getUtxosWithUnit by Credential Type is not supported in Koios yet."
-      );
-    }
+        })
+      ),
+      Effect3.timeout(1e4),
+      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect3.runPromise
+    );
+    return result;
   }
   async getUtxoByUnit(unit) {
-    let { policyId, assetName } = fromUnit2(unit);
-    assetName = String(assetName);
-    const assetAddresses = await fetch(
-      `${this.baseUrl}/asset_addresses?_asset_policy=${policyId}&_asset_name=${assetName}`
-    ).then((res) => res.json());
-    if (Array.isArray(assetAddresses) && assetAddresses.length > 0) {
-      if (assetAddresses.length > 1) {
-        throw new Error("Unit needs to be an NFT or only held by one address.");
-      }
-      const utxos = await this.getUtxos(
-        assetAddresses[0].payment_address
-      );
-      const result = utxos.find((utxo) => {
-        const keys = Object.keys(utxo.assets);
-        return keys.length > 0 && keys.includes(unit);
-      });
-      if (result) {
-        return result;
-      }
-    }
-    throw new Error("Unit not found.");
+    let { policyId, assetName } = fromUnit3(unit);
+    const url = `${this.baseUrl}/asset_addresses?_asset_policy=${policyId}&_asset_name=${assetName}`;
+    const result = await pipe4(
+      getWithSchemaValidation(url, S5.Array(AssetAddressSchema)),
+      Effect3.flatMap(
+        (adresses) => adresses.length === 0 ? Effect3.fail("Unit not found") : Effect3.succeed(adresses)
+      ),
+      Effect3.flatMap(
+        (adresses) => adresses.length > 1 ? Effect3.fail("Unit needs to be an NFT or only held by one address.") : Effect3.succeed(adresses[0])
+      ),
+      Effect3.flatMap(
+        (address) => getUtxosEffect(this.baseUrl, address.payment_address)
+      ),
+      Effect3.map(
+        (utxos) => utxos.filter((utxo) => {
+          const keys = Object.keys(utxo.assets);
+          return keys.length > 0 && keys.includes(unit);
+        })
+      ),
+      Effect3.flatMap(
+        (utxos) => utxos.length > 1 ? Effect3.fail("Unit needs to be an NFT or only held by one address.") : Effect3.succeed(utxos[0])
+      ),
+      Effect3.timeout(1e4),
+      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect3.runPromise
+    );
+    return result;
   }
   async getUtxosByOutRef(outRefs) {
+    const url = `${this.baseUrl}/tx_info`;
     const body = {
       _tx_hashes: [...new Set(outRefs.map((outRef) => outRef.txHash))],
       _assets: true,
       _scripts: true
     };
-    const result = await fetch(`${this.baseUrl}/tx_info`, {
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json"
-      },
-      method: "POST",
-      body: JSON.stringify(body)
-    }).then((res) => res.json());
-    const [parsedResult] = await pipe4(
-      S4.decodeUnknown(S4.Array(KoiosTxInfoSchema), {
-        onExcessProperty: "error",
-        errors: "first"
-      })(result),
-      Effect3.catchTag(
-        "ParseError",
-        (e) => Effect3.fail(ArrayFormatter2.formatErrorSync(e))
-      ),
+    const schema = S5.Array(TxInfoSchema);
+    const [result] = await pipe4(
+      postWithSchemaValidation(url, body, schema),
+      Effect3.timeout(1e4),
+      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
       Effect3.runPromise
     );
-    if (parsedResult) {
-      const utxos = parsedResult.outputs.map(
+    if (result) {
+      const utxos = result.outputs.map(
         (koiosInputOutput) => toUTxO(
           {
             tx_hash: koiosInputOutput.tx_hash,
             tx_index: koiosInputOutput.tx_index,
             block_time: 0,
-            block_height: parsedResult.block_height,
+            block_height: result.block_height,
             value: koiosInputOutput.value,
             datum_hash: koiosInputOutput.datum_hash,
             inline_datum: koiosInputOutput.inline_datum,
@@ -2440,135 +2456,94 @@ var Koios = class {
     const body = {
       _stake_addresses: [rewardAddress]
     };
-    const result = await fetch(`${this.baseUrl}/account_info`, {
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json"
-      },
-      method: "POST",
-      body: JSON.stringify(body)
-    }).then((res) => res.json());
-    if (Array.isArray(result) && result.length > 0) {
-      return {
-        poolId: result[0].delegated_pool || null,
-        rewards: BigInt(result[0].rewards_available)
-      };
-    } else {
-      throw new Error("No Delegation Found by Reward Address");
-    }
+    const url = `${this.baseUrl}/account_info`;
+    const result = await pipe4(
+      postWithSchemaValidation(
+        url,
+        body,
+        S5.Array(AccountInfoSchema)
+      ),
+      Effect3.flatMap(
+        (result2) => result2.length === 0 ? Effect3.fail("No Delegation Found by Reward Address") : Effect3.succeed(result2[0])
+      ),
+      Effect3.timeout(1e4),
+      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect3.runPromise
+    );
+    return {
+      poolId: result.delegated_pool || null,
+      rewards: BigInt(result.rewards_available)
+    };
   }
   async getDatum(datumHash) {
+    const url = `${this.baseUrl}/datum_info`;
     const body = {
       _datum_hashes: [datumHash]
     };
-    const datum = await fetch(`${this.baseUrl}/datum_info`, {
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json"
-      },
-      method: "POST",
-      body: JSON.stringify(body)
-    }).then((res) => res.json());
-    if (Array.isArray(datum) && datum.length > 0) {
-      return datum[0].bytes;
-    } else {
-      throw new Error("No Datum Found by Datum Hash");
-    }
+    const result = await pipe4(
+      postWithSchemaValidation(url, body, S5.Array(DatumInfo)),
+      Effect3.flatMap(
+        (result2) => result2.length === 0 ? Effect3.fail("No Datum Found by Datum Hash") : Effect3.succeed(result2[0])
+      ),
+      Effect3.timeout(1e4),
+      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect3.runPromise
+    );
+    return result.bytes;
   }
   async awaitTx(txHash, checkInterval = 2e4) {
+    const url = `${this.baseUrl}/tx_info`;
     const body = {
       _tx_hashes: [txHash]
     };
-    const request = {
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json"
-      },
-      method: "POST",
-      body: JSON.stringify(body)
-    };
-    const program = pipe4(
-      fetchEffect(`${this.baseUrl}/tx_info`, request),
-      Effect3.flatMap(
-        (json) => S4.decodeUnknown(S4.Array(KoiosTxInfoSchema))(json)
-      ),
-      Effect3.catchTag(
-        "ParseError",
-        (e) => Effect3.fail(ArrayFormatter2.formatErrorSync(e))
-      ),
+    const schema = S5.Array(TxInfoSchema);
+    const result = await pipe4(
+      postWithSchemaValidation(url, body, schema),
       Effect3.repeat({
         schedule: Schedule2.exponential(checkInterval),
-        until: (result) => result.length > 0
+        until: (result2) => result2.length > 0
       }),
       Effect3.timeout(16e4),
       Effect3.orDie,
-      Effect3.as(true)
+      Effect3.as(true),
+      Effect3.runPromise
     );
-    return Effect3.runPromise(program);
+    return result;
   }
   async submitTx(tx) {
-    const result = await fetch(`${this.baseUrl}/submittx`, {
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/cbor"
-      },
-      method: "POST",
-      body: fromHex4(tx)
-    }).then((res) => res.json());
-    const TxHashSchema = S4.String;
-    const isTxHash = S4.is(TxHashSchema);
-    if (!isTxHash(result)) {
-      throw new Error(JSON.stringify(result));
-    }
+    const url = `${this.baseUrl}/submittx`;
+    const body = fromHex4(tx);
+    const schema = TxHashSchema;
+    const result = await pipe4(
+      postWithSchemaValidation(url, body, schema),
+      Effect3.timeout(1e4),
+      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect3.runPromise
+    );
     return result;
   }
   async evaluateTx(tx, additionalUTxOs) {
-    const utxos = (additionalUTxOs || []).map((utxo) => {
-      const script = utxo.scriptRef ? {
-        language: utxo.scriptRef.type,
-        cbor: utxo.scriptRef.script
-      } : void 0;
-      return [
-        {
-          transaction: { id: utxo.txHash, output: { index: utxo.outputIndex } }
-        },
-        {
-          address: utxo.address,
-          value: {
-            coins: utxo.assets.lovelace,
-            assets: utxo.assets.restAssets
-          },
-          datumHash: utxo.datumHash,
-          datum: utxo.datum,
-          script
-        }
-      ];
-    });
-    const data = {
+    const url = `${this.baseUrl}/ogmios`;
+    const body = {
       jsonrpc: "2.0",
       method: "evaluateTransaction",
-      params: { transaction: { cbor: tx }, additionalUTxO: utxos },
+      params: {
+        transaction: { cbor: tx },
+        additionalUtxo: toOgmiosUTxOs(additionalUTxOs)
+      },
       id: null
     };
-    const response = await fetch(`${this.baseUrl}/ogmios`, {
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json"
-      },
-      method: "POST",
-      body: JSON.stringify(
-        data,
-        (_, value) => typeof value === "bigint" ? value.toString() : value
-      )
-    });
-    if (!response.ok) {
-      const errorBody = await response.text();
-      throw new Error(
-        `Request failed with status ${response.status}: ${errorBody}`
-      );
-    }
-    const result = await response.json();
-    const evalRedeemers = result.result.map((item) => ({
+    const schema = JSONRPCSchema(S5.Array(RedeemerSchema));
+    const result = await pipe4(
+      postWithSchemaValidation(url, body, schema),
+      Effect3.flatMap(
+        (response) => "error" in response ? Effect3.fail(response) : Effect3.succeed(response.result)
+      ),
+      Effect3.timeout(1e4),
+      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect3.runPromise
+    );
+    const evalRedeemers = result.map((item) => ({
       ex_units: {
         mem: item.budget.memory,
         steps: item.budget.cpu
@@ -2579,55 +2554,13 @@ var Koios = class {
     return evalRedeemers;
   }
 };
-var toUTxO = (koiosUTxO, address) => ({
-  txHash: koiosUTxO.tx_hash,
-  outputIndex: koiosUTxO.tx_index,
-  assets: (() => {
-    const a = {};
-    if (koiosUTxO.asset_list) {
-      koiosUTxO.asset_list.forEach((am) => {
-        a[am.policy_id + am.asset_name] = BigInt(am.quantity);
-      });
-    }
-    a["lovelace"] = BigInt(koiosUTxO.value);
-    return a;
-  })(),
-  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)
-});
-var toScriptRef2 = (reference_script) => {
-  if (reference_script && reference_script.bytes && reference_script.type) {
-    switch (reference_script.type) {
-      case "plutusV1":
-        return {
-          type: "PlutusV1",
-          script: applyDoubleCborEncoding4(reference_script.bytes)
-        };
-      case "plutusV2":
-        return {
-          type: "PlutusV2",
-          script: applyDoubleCborEncoding4(reference_script.bytes)
-        };
-      case "plutusV3":
-        return {
-          type: "PlutusV3",
-          script: applyDoubleCborEncoding4(reference_script.bytes)
-        };
-      default:
-        return void 0;
-    }
-  }
-};
 export {
   Blockfrost,
   Emulator,
-  fetch_exports as FetchProvider,
   Koios,
+  KoiosError,
   Kupmios,
   KupmiosError,
   Maestro,
-  datumJsonToCbor,
   generateEmulatorAccount
 };