@lucid-evolution/provider 0.1.43 → 0.1.45

package/dist/index.js

@@ -7,14 +7,14 @@ var __export = (target, all) => {
 // src/core.ts
 import * as CML from "@anastasia-labs/cardano-multiplatform-lib-nodejs";
 
-// src/blockfrost.ts
+// src/blockfrost/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.43",
+  version: "0.1.45",
   description: "",
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
@@ -62,7 +62,8 @@ var package_default = {
   }
 };
 
-// src/blockfrost.ts
+// src/blockfrost/blockfrost.ts
+import { pipe, Record } from "effect";
 var Blockfrost = class {
   url;
   projectId;
@@ -288,6 +289,11 @@ var Blockfrost = class {
                     type: "PlutusV2",
                     script: applyDoubleCborEncoding(script)
                   };
+                case "plutusV3":
+                  return {
+                    type: "PlutusV3",
+                    script: applyDoubleCborEncoding(script)
+                  };
               }
             })() : void 0
           };
@@ -298,19 +304,9 @@ var Blockfrost = class {
     return utxos;
   }
   async evaluateTx(tx, additionalUTxOs) {
-    const additionalUTxOSet = (additionalUTxOs || []).map((utxo) => [
-      { txId: utxo.txHash, index: utxo.outputIndex },
-      {
-        address: utxo.address,
-        value: { coins: utxo.assets.lovelace, assets: utxo.assets.restAssets },
-        datum_hash: utxo.datumHash,
-        datum: utxo.datum,
-        script: utxo.scriptRef
-      }
-    ]);
     const payload = {
       cbor: tx,
-      additionalUTxOSet
+      additionalUtxoSet: toAditionalUTXOs(additionalUTxOs)
     };
     const res = await fetch(`${this.url}/utils/txs/evaluate/utxos`, {
       method: "POST",
@@ -319,10 +315,7 @@ var Blockfrost = class {
         project_id: this.projectId,
         lucid
       },
-      body: JSON.stringify(
-        payload,
-        (_, value) => typeof value === "bigint" ? value.toString() : value
-      )
+      body: JSON.stringify(payload)
     }).then((res2) => res2.json());
     if (!res || res.error) {
       const message = res?.status_code === 400 ? res.message : `Could not evaluate the transaction: ${JSON.stringify(res)}`;
@@ -386,17 +379,55 @@ function datumJsonToCbor(json) {
 }
 var handleRateLimit = async (count) => {
   if (count % 100 === 0) {
-    await sleep(1e3);
+    await sleep(5e3);
   } else if (count % 10 === 0) {
-    await sleep(100);
+    await sleep(500);
   }
 };
 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 { fromUnit } from "@lucid-evolution/utils";
+import { applyDoubleCborEncoding as applyDoubleCborEncoding2, fromUnit } from "@lucid-evolution/utils";
 import * as S2 from "@effect/schema/Schema";
-import { Effect, pipe, Array as _Array, Schedule, Data } from "effect";
+import { Effect, pipe as pipe2, Array as _Array, Schedule, Data } from "effect";
 
 // src/kupmios/schema.ts
 import * as S from "@effect/schema/Schema";
@@ -417,6 +448,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 }),
@@ -433,7 +509,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,
@@ -466,11 +543,16 @@ var KupoUTxO = S.Struct({
     slot_no: S.Number,
     header_hash: S.String
   }),
-  spent_at: S.NullOr(S.Number)
+  spent_at: S.NullOr(
+    S.Struct({
+      slot_no: S.Number,
+      header_hash: S.String
+    })
+  )
 });
 var KupoScriptSchema = S.NullOr(
   S.Struct({
-    language: S.Literal("native", "plutus:v1", "plutus:v2"),
+    language: S.Literal("native", "plutus:v1", "plutus:v2", "plutus:v3"),
     script: S.String
   })
 );
@@ -492,6 +574,7 @@ import {
   HttpClientRequest,
   HttpClientResponse
 } from "@effect/platform";
+import { ArrayFormatter } from "@effect/schema";
 var KupmiosError = class extends Data.TaggedError("KupmiosError") {
   get message() {
     return `${this.cause}`;
@@ -628,7 +711,7 @@ var Kupmios = class {
     return result.datum;
   }
   async awaitTx(txHash, checkInterval = 2e4) {
-    const pattern = `${this.kupoUrl}/matches/*@${txHash}?unspent`;
+    const pattern = `${this.kupoUrl}/matches/*@${txHash}`;
     const schema = S2.Array(KupoUTxO).annotations({
       identifier: "Array<KupmiosSchema.KupoUTxO>"
     });
@@ -739,28 +822,34 @@ var getDatumEffect = (kupoUrl, datum_type, datum_hash) => Effect.gen(function* (
       Effect.map((result) => result.datum),
       Effect.timeout(1e4)
     );
-  } else return null;
+  } else return void 0;
 });
 var getScriptEffect = (kupoUrl, script_hash) => Effect.gen(function* () {
   if (script_hash) {
     const pattern = `${kupoUrl}/scripts/${script_hash}`;
     const schema = KupoScriptSchema;
-    return yield* pipe(
+    return yield* pipe2(
       fetchKupoParse(pattern, schema),
       Effect.flatMap(Effect.fromNullable),
       Effect.timeout(1e4),
       Effect.map(({ language, script }) => {
         switch (language) {
           case "native":
-            return { type: "Native", script };
+            return void 0;
           case "plutus:v1":
-            return { type: "PlutusV1", script };
+            return {
+              type: "PlutusV1",
+              script: applyDoubleCborEncoding2(script)
+            };
           case "plutus:v2":
-            return { type: "PlutusV2", script };
+            return {
+              type: "PlutusV2",
+              script: applyDoubleCborEncoding2(script)
+            };
         }
       })
     );
-  } else return null;
+  } else return void 0;
 });
 var toAssets = (value) => {
   const assets = { lovelace: BigInt(value.coins) };
@@ -801,35 +890,45 @@ var toProtocolParameters = (result) => {
           index.toString(),
           value
         ])
+      ),
+      PlutusV3: Object.fromEntries(
+        result.plutusCostModels["plutus:v3"].map((value, index) => [
+          index.toString(),
+          value
+        ])
       )
     }
   };
 };
-var fetchOgmiosParse = (url, data, schema) => pipe(
+var fetchOgmiosParse = (url, data, schema) => pipe2(
   HttpClientRequest.post(url),
   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(
+    S2.decodeUnknown(schema, { onExcessProperty: "error", errors: "first" })
+  ),
+  Effect.catchTag(
+    "ParseError",
+    (e) => Effect.fail(ArrayFormatter.formatErrorSync(e))
+  )
   // Effect.scoped
 );
-var fetchKupoParse = (url, schema) => pipe(
+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(S2.decodeUnknown(schema, { onExcessProperty: "error" })),
+  Effect.catchTag(
+    "ParseError",
+    (e) => Effect.fail(ArrayFormatter.formatErrorSync(e))
+  )
   // Effect.scoped
 );
 var kupmiosUtxosToUtxos = (kupoURL, utxos) => Effect.forEach(
   utxos,
   (utxo) => {
-    return pipe(
+    return pipe2(
       Effect.all([
         getDatumEffect(kupoURL, utxo.datum_type, utxo.datum_hash),
         getScriptEffect(kupoURL, utxo.script_hash)
@@ -840,7 +939,7 @@ var kupmiosUtxosToUtxos = (kupoURL, utxos) => Effect.forEach(
           outputIndex: utxo.output_index,
           address: utxo.address,
           assets: toAssets(utxo.value),
-          datumHash: utxo.datum_type === "hash" ? utxo.datum_hash : null,
+          datumHash: utxo.datum_type === "hash" ? utxo.datum_hash : void 0,
           datum,
           scriptRef: script
         })
@@ -1200,12 +1299,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;
     })();
@@ -1575,7 +1689,7 @@ function redeemerTagToString(tag) {
 }
 
 // src/maestro.ts
-import { applyDoubleCborEncoding as applyDoubleCborEncoding2, utxoToCore } from "@lucid-evolution/utils";
+import { applyDoubleCborEncoding as applyDoubleCborEncoding3, utxoToCore } from "@lucid-evolution/utils";
 import { fromHex as fromHex3 } from "@lucid-evolution/core-utils";
 var Maestro = class {
   url;
@@ -1587,7 +1701,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;
@@ -1595,37 +1709,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) {
@@ -1808,10 +1924,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: applyDoubleCborEncoding2(result.reference_script.bytes)
-      } : void 0
+      scriptRef: toScriptRef(result.reference_script)
     };
   }
   async getAllPagesData(getResponse, qry, paramsGiven, errorMsg) {
@@ -1862,16 +1975,61 @@ 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";
 import { fromHex as fromHex4 } from "@lucid-evolution/core-utils";
-import { applyDoubleCborEncoding as applyDoubleCborEncoding3, fromUnit as fromUnit2 } from "@lucid-evolution/utils";
+import { applyDoubleCborEncoding as applyDoubleCborEncoding4, fromUnit as fromUnit2 } 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,
@@ -1895,7 +2053,8 @@ var ProtocolParametersSchema2 = S3.Struct({
   block_hash: S3.NullOr(S3.String),
   cost_models: S3.Struct({
     PlutusV1: S3.Array(S3.Number),
-    PlutusV2: S3.Array(S3.Number)
+    PlutusV2: S3.Array(S3.Number),
+    PlutusV3: S3.Array(S3.Number)
   }),
   price_mem: S3.Number,
   price_step: S3.Number,
@@ -1915,9 +2074,17 @@ var KoiosAssetSchema = S3.Struct({
   decimals: S3.Number,
   quantity: S3.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 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),
@@ -1927,15 +2094,7 @@ var KoiosUTxOSchema = S3.Struct({
       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)
-    })
-  ),
+  reference_script: S3.NullOr(ReferenceScriptSchema),
   asset_list: S3.NullOr(S3.Array(KoiosAssetSchema))
 });
 var KoiosAddressInfoSchema = S3.Array(
@@ -1965,16 +2124,8 @@ var KoiosInputOutputSchema = S3.Struct({
       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)
-    })
-  ),
-  asset_list: S3.Union(S3.Array(KoiosAssetSchema), S3.String)
+  reference_script: S3.NullOr(ReferenceScriptSchema),
+  asset_list: S3.Array(KoiosAssetSchema)
 });
 var KoiosTxInfoSchema = S3.Struct({
   tx_hash: S3.String,
@@ -1988,6 +2139,7 @@ var KoiosTxInfoSchema = S3.Struct({
   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),
@@ -2057,12 +2209,18 @@ var KoiosTxInfoSchema = S3.Struct({
         })
       })
     )
-  )
+  ),
+  //TODO: add S.Struct
+  // https://preprod.koios.rest/#post-/tx_info
+  voting_procedures: S3.Array(S3.Object),
+  //TODO: add S.Struct
+  // https://preprod.koios.rest/#post-/tx_info
+  proposal_procedures: S3.Object
 });
 
 // src/koios/koios.ts
-import { Effect as Effect3, pipe as pipe3, Schedule as Schedule2 } from "effect";
-import { ArrayFormatter } from "@effect/schema";
+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 = {};
@@ -2072,14 +2230,14 @@ __export(fetch_exports, {
   ResponseError: () => ResponseError,
   fetchEffect: () => fetchEffect
 });
-import { Data as Data2, Effect as Effect2, pipe as pipe2 } from "effect";
+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 JsonError = class extends Data2.TaggedError("JsonError") {
 };
-var fetchEffect = (input, requestInit) => pipe2(
+var fetchEffect = (input, requestInit) => pipe3(
   Effect2.tryPromise({
     try: () => fetch(input, requestInit),
     catch: (error) => new FetchError({
@@ -2109,7 +2267,17 @@ var Koios = class {
     const result = await fetch(`${this.baseUrl}/epoch_params?limit=1`).then(
       (res) => res.json()
     );
-    const param = S4.decodeUnknownSync(ProtocolParametersSchema2)(result[0]);
+    const param = await pipe4(
+      S4.decodeUnknown(ProtocolParametersSchema2, {
+        onExcessProperty: "error",
+        errors: "first"
+      })(result[0]),
+      Effect3.catchTag(
+        "ParseError",
+        (e) => Effect3.fail(ArrayFormatter2.formatErrorSync(e))
+      ),
+      Effect3.runPromise
+    );
     return {
       minFeeA: param.min_fee_a,
       minFeeB: param.min_fee_b,
@@ -2136,6 +2304,12 @@ var Koios = class {
             index.toString(),
             value
           ])
+        ),
+        PlutusV3: Object.fromEntries(
+          param.cost_models.PlutusV3.map((value, index) => [
+            index.toString(),
+            value
+          ])
         )
       }
     };
@@ -2153,9 +2327,17 @@ var Koios = class {
         method: "POST",
         body: JSON.stringify(body)
       }).then((res) => res.json());
-      const parsedResult = S4.decodeUnknownSync(KoiosAddressInfoSchema)(
-        result
-      )[0];
+      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)
       ) : [];
@@ -2204,9 +2386,10 @@ var Koios = class {
     throw new Error("Unit not found.");
   }
   async getUtxosByOutRef(outRefs) {
-    const utxos = [];
     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: {
@@ -2216,26 +2399,39 @@ var Koios = class {
       method: "POST",
       body: JSON.stringify(body)
     }).then((res) => res.json());
-    const parsedResult = S4.decodeUnknownSync(S4.Array(KoiosTxInfoSchema))(
-      result
-    )[0];
+    const [parsedResult] = await pipe4(
+      S4.decodeUnknown(S4.Array(KoiosTxInfoSchema), {
+        onExcessProperty: "error",
+        errors: "first"
+      })(result),
+      Effect3.catchTag(
+        "ParseError",
+        (e) => Effect3.fail(ArrayFormatter2.formatErrorSync(e))
+      ),
+      Effect3.runPromise
+    );
     if (parsedResult) {
-      return parsedResult.outputs.map(
+      const utxos = parsedResult.outputs.map(
         (koiosInputOutput) => toUTxO(
           {
             tx_hash: koiosInputOutput.tx_hash,
             tx_index: koiosInputOutput.tx_index,
-            block_height: null,
+            block_time: 0,
+            block_height: parsedResult.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 [];
     }
@@ -2291,14 +2487,14 @@ var Koios = class {
       method: "POST",
       body: JSON.stringify(body)
     };
-    const program = pipe3(
+    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))
+        (e) => Effect3.fail(ArrayFormatter2.formatErrorSync(e))
       ),
       Effect3.repeat({
         schedule: Schedule2.exponential(checkInterval),
@@ -2397,16 +2593,33 @@ var toUTxO = (koiosUTxO, address) => ({
     return a;
   })(),
   address,
-  datumHash: koiosUTxO.inline_datum ? void 0 : koiosUTxO.datum_hash,
+  datumHash: koiosUTxO.inline_datum ? void 0 : koiosUTxO.datum_hash || void 0,
   datum: koiosUTxO.inline_datum ? koiosUTxO.inline_datum.bytes : void 0,
-  scriptRef: koiosUTxO.reference_script ? koiosUTxO.reference_script.type == "plutusV1" ? {
-    type: "PlutusV1",
-    script: applyDoubleCborEncoding3(koiosUTxO.reference_script.bytes)
-  } : {
-    type: "PlutusV2",
-    script: applyDoubleCborEncoding3(koiosUTxO.reference_script.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,