@lucid-evolution/provider 0.1.44 → 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.44",
+  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;
@@ -289,6 +323,11 @@ var Blockfrost = class {
                     type: "PlutusV2",
                     script: applyDoubleCborEncoding(script)
                   };
+                case "plutusV3":
+                  return {
+                    type: "PlutusV3",
+                    script: applyDoubleCborEncoding(script)
+                  };
               }
             })() : void 0
           };
@@ -336,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);
@@ -380,38 +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: utxo.scriptRef ? utxo.scriptRef.type === "PlutusV1" ? { "plutus:v1": utxo.scriptRef.script } : { "plutus:v2": utxo.scriptRef.script } : 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,
@@ -429,6 +415,51 @@ var TupleNumberFromString = S.compose(
 );
 var ProtocolParametersSchema = S.Struct({
   minFeeCoefficient: S.Number,
+  minFeeReferenceScripts: S.Struct({
+    base: S.Number,
+    range: S.Number,
+    multiplier: S.Number
+  }),
+  maxReferenceScriptsSize: S.Struct({
+    bytes: S.Number
+  }),
+  stakePoolVotingThresholds: S.Struct({
+    noConfidence: TupleNumberFromString,
+    constitutionalCommittee: S.Struct({
+      default: TupleNumberFromString,
+      stateOfNoConfidence: TupleNumberFromString
+    }),
+    hardForkInitiation: TupleNumberFromString,
+    protocolParametersUpdate: S.Struct({
+      security: TupleNumberFromString
+    })
+  }),
+  delegateRepresentativeVotingThresholds: S.Struct({
+    noConfidence: TupleNumberFromString,
+    constitutionalCommittee: S.Struct({
+      default: TupleNumberFromString,
+      stateOfNoConfidence: TupleNumberFromString
+    }),
+    constitution: TupleNumberFromString,
+    hardForkInitiation: TupleNumberFromString,
+    protocolParametersUpdate: S.Struct({
+      network: TupleNumberFromString,
+      economic: TupleNumberFromString,
+      technical: TupleNumberFromString,
+      governance: TupleNumberFromString
+    }),
+    treasuryWithdrawals: TupleNumberFromString
+  }),
+  constitutionalCommitteeMinSize: S.Number,
+  constitutionalCommitteeMaxTermLength: S.Number,
+  governanceActionLifetime: S.Number,
+  governanceActionDeposit: S.Struct({
+    ada: LovelaceAsset
+  }),
+  delegateRepresentativeDeposit: S.Struct({
+    ada: LovelaceAsset
+  }),
+  delegateRepresentativeMaxIdleTime: S.Number,
   minFeeConstant: S.Struct({ ada: LovelaceAsset }),
   maxBlockBodySize: S.Struct({ bytes: S.Number }),
   maxBlockHeaderSize: S.Struct({ bytes: S.Number }),
@@ -445,7 +476,8 @@ var ProtocolParametersSchema = S.Struct({
   minUtxoDepositCoefficient: S.Number,
   plutusCostModels: S.Struct({
     "plutus:v1": S.Array(S.Number),
-    "plutus:v2": S.Array(S.Number)
+    "plutus:v2": S.Array(S.Number),
+    "plutus:v3": S.Array(S.Number)
   }),
   scriptExecutionPrices: S.Struct({
     memory: TupleNumberFromString,
@@ -461,62 +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 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 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 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"),
-    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";
+// 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;
@@ -535,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);
@@ -552,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;
@@ -564,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) {
@@ -595,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);
@@ -618,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;
@@ -635,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}?spent`;
-    const schema = S2.Array(KupoUTxO).annotations({
+    const pattern = `${this.kupoUrl}/matches/*@${txHash}`;
+    const schema = S3.Array(UTxOSchema).annotations({
       identifier: "Array<KupmiosSchema.KupoUTxO>"
     });
     const program = fetchKupoParse(pattern, schema).pipe(
@@ -655,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);
@@ -670,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) => ({
@@ -750,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),
@@ -761,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),
@@ -780,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)
+            };
         }
       })
     );
@@ -824,6 +884,12 @@ var toProtocolParameters = (result) => {
           index.toString(),
           value
         ])
+      ),
+      PlutusV3: Object.fromEntries(
+        result.plutusCostModels["plutus:v3"].map((value, index) => [
+          index.toString(),
+          value
+        ])
       )
     }
   };
@@ -833,20 +899,22 @@ var fetchOgmiosParse = (url, data, schema) => pipe2(
   HttpClientRequest.jsonBody(data),
   Effect.flatMap(HttpClient.fetch),
   HttpClientResponse.json,
-  Effect.flatMap(S2.decodeUnknown(schema))
-  // Effect.catchTag("ParseError", (e) =>
-  //   Effect.fail(ArrayFormatter.formatIssueSync(e.issue)),
-  // ),
+  Effect.flatMap(S3.decodeUnknown(schema, { onExcessProperty: "error" })),
+  Effect.catchTag(
+    "ParseError",
+    (e) => Effect.fail(ArrayFormatter.formatErrorSync(e))
+  )
   // Effect.scoped
 );
 var fetchKupoParse = (url, schema) => pipe2(
   HttpClientRequest.get(url),
   HttpClient.fetchOk,
   HttpClientResponse.json,
-  Effect.flatMap(S2.decodeUnknown(schema))
-  // Effect.catchTag("ParseError", (e) =>
-  //   Effect.fail(ArrayFormatter.formatIssueSync(e.issue)),
-  // ),
+  Effect.flatMap(S3.decodeUnknown(schema, { onExcessProperty: "error" })),
+  Effect.catchTag(
+    "ParseError",
+    (e) => Effect.fail(ArrayFormatter.formatErrorSync(e))
+  )
   // Effect.scoped
 );
 var kupmiosUtxosToUtxos = (kupoURL, utxos) => Effect.forEach(
@@ -1223,12 +1291,27 @@ It does not exist or was already spent.`
         3: "Reward"
       };
       const collected = [];
-      for (let i = 0; i < (witnesses.redeemers()?.to_js_value().len() || 0); i++) {
-        const redeemer = witnesses.redeemers().to_js_value().get(i);
-        collected.push({
-          tag: tagMap[redeemer.tag().kind()],
-          index: parseInt(redeemer.index().to_str())
-        });
+      const redeemers2 = witnesses.redeemers();
+      const arrLegacyRedeemer = redeemers2?.as_arr_legacy_redeemer();
+      if (arrLegacyRedeemer) {
+        for (let i = 0; i < (arrLegacyRedeemer.len() || 0); i++) {
+          const redeemer = arrLegacyRedeemer.get(i);
+          collected.push({
+            tag: tagMap[redeemer.tag()],
+            index: Number(redeemer.index())
+          });
+        }
+      }
+      const mapRedeemerKeyToRedeemerVal = redeemers2?.as_map_redeemer_key_to_redeemer_val();
+      if (mapRedeemerKeyToRedeemerVal) {
+        const keys = mapRedeemerKeyToRedeemerVal.keys();
+        for (let i = 0; i < (keys.len() || 0); i++) {
+          const key = keys.get(i);
+          collected.push({
+            tag: tagMap[key.tag()],
+            index: Number(key.index())
+          });
+        }
       }
       return collected;
     })();
@@ -1610,7 +1693,7 @@ var Maestro = class {
     this.turboSubmit = turboSubmit;
   }
   async getProtocolParameters() {
-    const timestampedResult = await fetch(`${this.url}/protocol-params`, {
+    const timestampedResult = await fetch(`${this.url}/protocol-parameters`, {
       headers: this.commonHeaders()
     }).then((res) => res.json());
     const result = timestampedResult.data;
@@ -1618,37 +1701,39 @@ var Maestro = class {
       const forwardSlashIndex = str.indexOf("/");
       return parseInt(str.slice(0, forwardSlashIndex)) / parseInt(str.slice(forwardSlashIndex + 1));
     };
-    const renameKeysAndSort = (obj, newKeys) => {
-      const entries = Object.keys(obj).sort().map((key) => {
-        const newKey = newKeys[key] || key;
-        return {
-          [newKey]: Object.fromEntries(
-            Object.entries(obj[key]).sort(
-              ([k, _v], [k2, _v2]) => k.localeCompare(k2)
-            )
-          )
-        };
-      });
-      return Object.assign({}, ...entries);
-    };
     return {
       minFeeA: parseInt(result.min_fee_coefficient),
-      minFeeB: parseInt(result.min_fee_constant),
-      maxTxSize: parseInt(result.max_tx_size),
-      maxValSize: parseInt(result.max_value_size),
-      keyDeposit: BigInt(result.stake_key_deposit),
-      poolDeposit: BigInt(result.pool_deposit),
-      priceMem: decimalFromRationalString(result.prices.memory),
-      priceStep: decimalFromRationalString(result.prices.steps),
+      minFeeB: parseInt(result.min_fee_constant.ada.lovelace),
+      maxTxSize: parseInt(result.max_transaction_size.bytes),
+      maxValSize: parseInt(result.max_value_size.bytes),
+      keyDeposit: BigInt(result.stake_credential_deposit.ada.lovelace),
+      poolDeposit: BigInt(result.stake_pool_deposit.ada.lovelace),
+      priceMem: decimalFromRationalString(
+        result.script_execution_prices.memory
+      ),
+      priceStep: decimalFromRationalString(result.script_execution_prices.cpu),
       maxTxExMem: BigInt(result.max_execution_units_per_transaction.memory),
-      maxTxExSteps: BigInt(result.max_execution_units_per_transaction.steps),
-      coinsPerUtxoByte: BigInt(result.coins_per_utxo_byte),
+      maxTxExSteps: BigInt(result.max_execution_units_per_transaction.cpu),
+      coinsPerUtxoByte: BigInt(result.min_utxo_deposit_coefficient),
       collateralPercentage: parseInt(result.collateral_percentage),
       maxCollateralInputs: parseInt(result.max_collateral_inputs),
-      costModels: renameKeysAndSort(result.cost_models, {
-        "plutus:v1": "PlutusV1",
-        "plutus:v2": "PlutusV2"
-      })
+      costModels: {
+        PlutusV1: Object.fromEntries(
+          result.plutus_cost_models.plutus_v1.map(
+            (value, index) => [index.toString(), value]
+          )
+        ),
+        PlutusV2: Object.fromEntries(
+          result.plutus_cost_models.plutus_v2.map(
+            (value, index) => [index.toString(), value]
+          )
+        ),
+        PlutusV3: Object.fromEntries(
+          result.plutus_cost_models.plutus_v2.map(
+            (value, index) => [index.toString(), value]
+          )
+        )
+      }
     };
   }
   async getUtxosInternal(addressOrCredential, unit) {
@@ -1831,10 +1916,7 @@ var Maestro = class {
       address: result.address,
       datumHash: result.datum ? result.datum.type == "inline" ? void 0 : result.datum.hash : void 0,
       datum: result.datum?.bytes,
-      scriptRef: result.reference_script ? result.reference_script.type == "native" ? void 0 : {
-        type: result.reference_script.type == "plutusv1" ? "PlutusV1" : "PlutusV2",
-        script: applyDoubleCborEncoding3(result.reference_script.bytes)
-      } : void 0
+      scriptRef: toScriptRef(result.reference_script)
     };
   }
   async getAllPagesData(getResponse, qry, paramsGiven, errorMsg) {
@@ -1859,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",
@@ -1885,277 +1967,391 @@ var Maestro = class {
     return result;
   }
 };
+var toScriptRef = (reference_script) => {
+  if (reference_script && reference_script.bytes) {
+    switch (reference_script.type) {
+      case "plutusv1":
+        return {
+          type: "PlutusV1",
+          script: applyDoubleCborEncoding3(reference_script.bytes)
+        };
+      case "plutusv2":
+        return {
+          type: "PlutusV2",
+          script: applyDoubleCborEncoding3(reference_script.bytes)
+        };
+      case "plutusv3":
+        return {
+          type: "PlutusV3",
+          script: applyDoubleCborEncoding3(reference_script.bytes)
+        };
+      default:
+        return void 0;
+    }
+  }
+};
 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({
-  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)
+// 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 KoiosUTxOSchema = S3.Struct({
-  tx_hash: S3.String,
-  tx_index: 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
-    })
-  ),
-  reference_script: S3.NullOr(
-    S3.Struct({
-      hash: S3.String,
-      size: S3.Number,
-      type: S3.String,
-      bytes: 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 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
     })
   ),
-  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
-    })
-  ),
-  reference_script: S3.NullOr(
-    S3.Struct({
-      hash: S3.String,
-      size: S3.Number,
-      type: S3.String,
-      bytes: S3.String,
-      value: S3.NullOr(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
     })
   ),
-  asset_list: S3.Union(S3.Array(KoiosAssetSchema), S3.String)
+  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,
-  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)
           })
         })
       })
     )
-  )
+  ),
+  //TODO: add S.Struct
+  // https://preprod.koios.rest/#post-/tx_info
+  voting_procedures: S4.Array(S4.Object),
+  //TODO: add S.Struct
+  // https://preprod.koios.rest/#post-/tx_info
+  proposal_procedures: S4.Object
 });
-
-// src/koios/koios.ts
-import { Effect as Effect3, pipe as pipe4, Schedule as Schedule2 } from "effect";
-import { ArrayFormatter } 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 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
     );
-    const param = S4.decodeUnknownSync(ProtocolParametersSchema2)(result[0]);
     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(
+          result.cost_models.PlutusV3.map((value, index) => [
             index.toString(),
             value
           ])
@@ -2164,101 +2360,94 @@ 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 = S4.decodeUnknownSync(KoiosAddressInfoSchema)(
-        result
-      )[0];
-      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 utxos = [];
+    const url = `${this.baseUrl}/tx_info`;
     const body = {
-      _tx_hashes: [...new Set(outRefs.map((outRef) => outRef.txHash))]
+      _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 = S4.decodeUnknownSync(S4.Array(KoiosTxInfoSchema))(
-      result
-    )[0];
-    if (parsedResult) {
-      return parsedResult.outputs.map(
+    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 (result) {
+      const utxos = result.outputs.map(
         (koiosInputOutput) => toUTxO(
           {
             tx_hash: koiosInputOutput.tx_hash,
             tx_index: koiosInputOutput.tx_index,
-            block_height: null,
+            block_time: 0,
+            block_height: result.block_height,
             value: koiosInputOutput.value,
             datum_hash: koiosInputOutput.datum_hash,
             inline_datum: koiosInputOutput.inline_datum,
             reference_script: koiosInputOutput.reference_script,
-            //NOTE: Koios api returns collateral_output like  asset_list: "[]", instead of asset_list: []
-            asset_list: typeof koiosInputOutput.asset_list === "string" ? [] : koiosInputOutput.asset_list
+            asset_list: koiosInputOutput.asset_list
           },
           koiosInputOutput.payment_addr.bech32
         )
       );
+      return utxos.filter(
+        (utxo) => outRefs.some(
+          (outRef) => utxo.txHash === outRef.txHash && utxo.outputIndex === outRef.outputIndex
+        )
+      );
     } else {
       return [];
     }
@@ -2267,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(ArrayFormatter.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
@@ -2406,38 +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,
-  datum: koiosUTxO.inline_datum ? koiosUTxO.inline_datum.bytes : void 0,
-  scriptRef: koiosUTxO.reference_script ? koiosUTxO.reference_script.type == "plutusV1" ? {
-    type: "PlutusV1",
-    script: applyDoubleCborEncoding4(koiosUTxO.reference_script.bytes)
-  } : {
-    type: "PlutusV2",
-    script: applyDoubleCborEncoding4(koiosUTxO.reference_script.bytes)
-  } : void 0
-});
 export {
   Blockfrost,
   Emulator,
-  fetch_exports as FetchProvider,
   Koios,
+  KoiosError,
   Kupmios,
   KupmiosError,
   Maestro,
-  datumJsonToCbor,
   generateEmulatorAccount
 };