@lucid-evolution/provider 0.1.43 → 0.1.45

package/dist/index.cjs

@@ -45,14 +45,14 @@ module.exports = __toCommonJS(src_exports);
 // src/core.ts
 var CML = __toESM(require("@anastasia-labs/cardano-multiplatform-lib-nodejs"), 1);
 
-// src/blockfrost.ts
+// src/blockfrost/blockfrost.ts
 var import_core_utils = require("@lucid-evolution/core-utils");
 var import_utils = require("@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",
@@ -100,7 +100,8 @@ var package_default = {
   }
 };
 
-// src/blockfrost.ts
+// src/blockfrost/blockfrost.ts
+var import_effect = require("effect");
 var Blockfrost = class {
   url;
   projectId;
@@ -326,6 +327,11 @@ var Blockfrost = class {
                     type: "PlutusV2",
                     script: (0, import_utils.applyDoubleCborEncoding)(script)
                   };
+                case "plutusV3":
+                  return {
+                    type: "PlutusV3",
+                    script: (0, import_utils.applyDoubleCborEncoding)(script)
+                  };
               }
             })() : void 0
           };
@@ -336,19 +342,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",
@@ -357,10 +353,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)}`;
@@ -424,17 +417,55 @@ function datumJsonToCbor(json) {
 }
 var handleRateLimit = async (count) => {
   if (count % 100 === 0) {
-    await (0, import_core_utils.sleep)(1e3);
+    await (0, import_core_utils.sleep)(5e3);
   } else if (count % 10 === 0) {
-    await (0, import_core_utils.sleep)(100);
+    await (0, import_core_utils.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) => (0, import_effect.pipe)(
+  import_effect.Record.remove(assets, "lovelace"),
+  import_effect.Record.mapEntries((amount, unit) => [
+    unit.length === 56 ? unit.slice(0, 56) : unit.slice(0, 56) + "." + unit.slice(56),
+    Number(amount)
+  ]),
+  (r) => import_effect.Record.isEmptyRecord(r) ? void 0 : r
+);
 
 // src/kupmios/kupmios.ts
 var import_utils2 = require("@lucid-evolution/utils");
 var S2 = __toESM(require("@effect/schema/Schema"), 1);
-var import_effect = require("effect");
+var import_effect2 = require("effect");
 
 // src/kupmios/schema.ts
 var S = __toESM(require("@effect/schema/Schema"), 1);
@@ -455,6 +486,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 }),
@@ -471,7 +547,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,
@@ -504,11 +581,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
   })
 );
@@ -526,7 +608,8 @@ var KupoDelegation = S.NullOr(
 
 // src/kupmios/kupmios.ts
 var import_platform = require("@effect/platform");
-var KupmiosError = class extends import_effect.Data.TaggedError("KupmiosError") {
+var import_schema = require("@effect/schema");
+var KupmiosError = class extends import_effect2.Data.TaggedError("KupmiosError") {
   get message() {
     return `${this.cause}`;
   }
@@ -556,13 +639,13 @@ var Kupmios = class {
       ProtocolParametersSchema
     );
     const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      import_effect.Effect.flatMap(
-        (response) => "error" in response ? kupmiosError(response.error) : import_effect.Effect.succeed(response.result)
+      import_effect2.Effect.flatMap(
+        (response) => "error" in response ? kupmiosError(response.error) : import_effect2.Effect.succeed(response.result)
       ),
-      import_effect.Effect.timeout(1e4),
-      import_effect.Effect.catchAll(kupmiosError)
+      import_effect2.Effect.timeout(1e4),
+      import_effect2.Effect.catchAll(kupmiosError)
     );
-    const result = await import_effect.Effect.runPromise(program);
+    const result = await import_effect2.Effect.runPromise(program);
     return toProtocolParameters(result);
   }
   async getUtxos(addressOrCredential) {
@@ -571,11 +654,11 @@ var Kupmios = class {
     const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent`;
     const schema = S2.Array(KupoUTxO);
     const program = fetchKupoParse(pattern, schema).pipe(
-      import_effect.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-      import_effect.Effect.timeout(1e4),
-      import_effect.Effect.catchAll(kupmiosError)
+      import_effect2.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      import_effect2.Effect.timeout(1e4),
+      import_effect2.Effect.catchAll(kupmiosError)
     );
-    const utxos = await import_effect.Effect.runPromise(program);
+    const utxos = await import_effect2.Effect.runPromise(program);
     return utxos;
   }
   async getUtxosWithUnit(addressOrCredential, unit) {
@@ -585,11 +668,11 @@ var Kupmios = class {
     const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&policy_id=${policyId}${assetName ? `&asset_name=${assetName}` : ""}`;
     const schema = S2.Array(KupoUTxO);
     const program = fetchKupoParse(pattern, schema).pipe(
-      import_effect.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-      import_effect.Effect.timeout(1e4),
-      import_effect.Effect.catchAll(kupmiosError)
+      import_effect2.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      import_effect2.Effect.timeout(1e4),
+      import_effect2.Effect.catchAll(kupmiosError)
     );
-    const utxos = await import_effect.Effect.runPromise(program);
+    const utxos = await import_effect2.Effect.runPromise(program);
     return utxos;
   }
   async getUtxoByUnit(unit) {
@@ -597,11 +680,11 @@ var Kupmios = class {
     const pattern = `${this.kupoUrl}/matches/${policyId}.${assetName ? `${assetName}` : "*"}?unspent`;
     const schema = S2.Array(KupoUTxO);
     const program = fetchKupoParse(pattern, schema).pipe(
-      import_effect.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-      import_effect.Effect.timeout(1e4),
-      import_effect.Effect.catchAll(kupmiosError)
+      import_effect2.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      import_effect2.Effect.timeout(1e4),
+      import_effect2.Effect.catchAll(kupmiosError)
     );
-    const utxos = await import_effect.Effect.runPromise(program);
+    const utxos = await import_effect2.Effect.runPromise(program);
     if (utxos.length > 1) {
       throw new Error("Unit needs to be an NFT or only held by one address.");
     }
@@ -613,16 +696,16 @@ var Kupmios = class {
     ];
     const mkPattern = (txHash) => `${this.kupoUrl}/matches/*@${txHash}?unspent`;
     const schema = S2.Array(KupoUTxO);
-    const program = import_effect.Effect.forEach(
+    const program = import_effect2.Effect.forEach(
       queryHashes,
       (txHash) => fetchKupoParse(mkPattern(txHash), schema).pipe(
-        import_effect.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-        import_effect.Effect.timeout(1e4),
-        import_effect.Effect.catchAll(kupmiosError)
+        import_effect2.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+        import_effect2.Effect.timeout(1e4),
+        import_effect2.Effect.catchAll(kupmiosError)
       )
     );
-    const utxos = await import_effect.Effect.runPromise(program);
-    return import_effect.Array.flatten(utxos).filter(
+    const utxos = await import_effect2.Effect.runPromise(program);
+    return import_effect2.Array.flatten(utxos).filter(
       (utxo) => outRefs.some(
         (outRef) => utxo.txHash === outRef.txHash && utxo.outputIndex === outRef.outputIndex
       )
@@ -637,13 +720,13 @@ var Kupmios = class {
     };
     const schema = JSONRPCSchema(KupoDelegation);
     const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      import_effect.Effect.flatMap(
-        (response) => "error" in response ? kupmiosError(response.error) : import_effect.Effect.succeed(response.result)
+      import_effect2.Effect.flatMap(
+        (response) => "error" in response ? kupmiosError(response.error) : import_effect2.Effect.succeed(response.result)
       ),
-      import_effect.Effect.timeout(1e4),
-      import_effect.Effect.catchAll(kupmiosError)
+      import_effect2.Effect.timeout(1e4),
+      import_effect2.Effect.catchAll(kupmiosError)
     );
-    const result = await import_effect.Effect.runPromise(program);
+    const result = await import_effect2.Effect.runPromise(program);
     const delegation = result ? Object.values(result)[0] : null;
     return {
       poolId: delegation?.delegate?.id || null,
@@ -654,28 +737,28 @@ var Kupmios = class {
     const pattern = `${this.kupoUrl}/datums/${datumHash}`;
     const schema = KupoDatumSchema;
     const program = fetchKupoParse(pattern, schema).pipe(
-      import_effect.Effect.timeout(1e4),
-      import_effect.Effect.flatMap(import_effect.Effect.fromNullable),
-      import_effect.Effect.catchAll(kupmiosError)
+      import_effect2.Effect.timeout(1e4),
+      import_effect2.Effect.flatMap(import_effect2.Effect.fromNullable),
+      import_effect2.Effect.catchAll(kupmiosError)
     );
-    const result = await import_effect.Effect.runPromise(program);
+    const result = await import_effect2.Effect.runPromise(program);
     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>"
     });
     const program = fetchKupoParse(pattern, schema).pipe(
-      import_effect.Effect.repeat({
-        schedule: import_effect.Schedule.exponential(checkInterval),
+      import_effect2.Effect.repeat({
+        schedule: import_effect2.Schedule.exponential(checkInterval),
         until: (result) => result.length > 0
       }),
-      import_effect.Effect.timeout(16e4),
-      import_effect.Effect.catchAll(kupmiosError),
-      import_effect.Effect.as(true)
+      import_effect2.Effect.timeout(16e4),
+      import_effect2.Effect.catchAll(kupmiosError),
+      import_effect2.Effect.as(true)
     );
-    return await import_effect.Effect.runPromise(program);
+    return await import_effect2.Effect.runPromise(program);
   }
   async submitTx(cbor) {
     const data = {
@@ -694,13 +777,13 @@ var Kupmios = class {
       })
     );
     const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      import_effect.Effect.flatMap(
-        (response) => "error" in response ? import_effect.Effect.fail(response.error) : import_effect.Effect.succeed(response)
+      import_effect2.Effect.flatMap(
+        (response) => "error" in response ? import_effect2.Effect.fail(response.error) : import_effect2.Effect.succeed(response)
       ),
-      import_effect.Effect.timeout(1e4),
-      import_effect.Effect.catchAll(kupmiosError)
+      import_effect2.Effect.timeout(1e4),
+      import_effect2.Effect.catchAll(kupmiosError)
     );
-    const { result } = await import_effect.Effect.runPromise(program);
+    const { result } = await import_effect2.Effect.runPromise(program);
     return result.transaction.id;
   }
   async evaluateTx(tx, additionalUTxOs) {
@@ -746,13 +829,13 @@ var Kupmios = class {
       )
     );
     const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      import_effect.Effect.flatMap(
-        (response) => "error" in response ? kupmiosError(response.error) : import_effect.Effect.succeed(response.result)
+      import_effect2.Effect.flatMap(
+        (response) => "error" in response ? kupmiosError(response.error) : import_effect2.Effect.succeed(response.result)
       ),
-      import_effect.Effect.timeout(1e4),
-      import_effect.Effect.catchAll(kupmiosError)
+      import_effect2.Effect.timeout(1e4),
+      import_effect2.Effect.catchAll(kupmiosError)
     );
-    const result = await import_effect.Effect.runPromise(program);
+    const result = await import_effect2.Effect.runPromise(program);
     const evalRedeemers = result.map((item) => ({
       ex_units: {
         mem: item.budget.memory,
@@ -764,37 +847,43 @@ var Kupmios = class {
     return evalRedeemers;
   }
 };
-var getDatumEffect = (kupoUrl, datum_type, datum_hash) => import_effect.Effect.gen(function* () {
+var getDatumEffect = (kupoUrl, datum_type, datum_hash) => import_effect2.Effect.gen(function* () {
   if (datum_type === "inline" && datum_hash) {
     const pattern = `${kupoUrl}/datums/${datum_hash}`;
     const schema = KupoDatumSchema;
     return yield* fetchKupoParse(pattern, schema).pipe(
-      import_effect.Effect.flatMap(import_effect.Effect.fromNullable),
-      import_effect.Effect.map((result) => result.datum),
-      import_effect.Effect.timeout(1e4)
+      import_effect2.Effect.flatMap(import_effect2.Effect.fromNullable),
+      import_effect2.Effect.map((result) => result.datum),
+      import_effect2.Effect.timeout(1e4)
     );
-  } else return null;
+  } else return void 0;
 });
-var getScriptEffect = (kupoUrl, script_hash) => import_effect.Effect.gen(function* () {
+var getScriptEffect = (kupoUrl, script_hash) => import_effect2.Effect.gen(function* () {
   if (script_hash) {
     const pattern = `${kupoUrl}/scripts/${script_hash}`;
     const schema = KupoScriptSchema;
-    return yield* (0, import_effect.pipe)(
+    return yield* (0, import_effect2.pipe)(
       fetchKupoParse(pattern, schema),
-      import_effect.Effect.flatMap(import_effect.Effect.fromNullable),
-      import_effect.Effect.timeout(1e4),
-      import_effect.Effect.map(({ language, script }) => {
+      import_effect2.Effect.flatMap(import_effect2.Effect.fromNullable),
+      import_effect2.Effect.timeout(1e4),
+      import_effect2.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: (0, import_utils2.applyDoubleCborEncoding)(script)
+            };
           case "plutus:v2":
-            return { type: "PlutusV2", script };
+            return {
+              type: "PlutusV2",
+              script: (0, import_utils2.applyDoubleCborEncoding)(script)
+            };
         }
       })
     );
-  } else return null;
+  } else return void 0;
 });
 var toAssets = (value) => {
   const assets = { lovelace: BigInt(value.coins) };
@@ -835,46 +924,56 @@ var toProtocolParameters = (result) => {
           index.toString(),
           value
         ])
+      ),
+      PlutusV3: Object.fromEntries(
+        result.plutusCostModels["plutus:v3"].map((value, index) => [
+          index.toString(),
+          value
+        ])
       )
     }
   };
 };
-var fetchOgmiosParse = (url, data, schema) => (0, import_effect.pipe)(
+var fetchOgmiosParse = (url, data, schema) => (0, import_effect2.pipe)(
   import_platform.HttpClientRequest.post(url),
   import_platform.HttpClientRequest.jsonBody(data),
-  import_effect.Effect.flatMap(import_platform.HttpClient.fetch),
+  import_effect2.Effect.flatMap(import_platform.HttpClient.fetch),
   import_platform.HttpClientResponse.json,
-  import_effect.Effect.flatMap(S2.decodeUnknown(schema))
-  // Effect.catchTag("ParseError", (e) =>
-  //   Effect.fail(ArrayFormatter.formatIssueSync(e.issue)),
-  // ),
+  import_effect2.Effect.flatMap(
+    S2.decodeUnknown(schema, { onExcessProperty: "error", errors: "first" })
+  ),
+  import_effect2.Effect.catchTag(
+    "ParseError",
+    (e) => import_effect2.Effect.fail(import_schema.ArrayFormatter.formatErrorSync(e))
+  )
   // Effect.scoped
 );
-var fetchKupoParse = (url, schema) => (0, import_effect.pipe)(
+var fetchKupoParse = (url, schema) => (0, import_effect2.pipe)(
   import_platform.HttpClientRequest.get(url),
   import_platform.HttpClient.fetchOk,
   import_platform.HttpClientResponse.json,
-  import_effect.Effect.flatMap(S2.decodeUnknown(schema))
-  // Effect.catchTag("ParseError", (e) =>
-  //   Effect.fail(ArrayFormatter.formatIssueSync(e.issue)),
-  // ),
+  import_effect2.Effect.flatMap(S2.decodeUnknown(schema, { onExcessProperty: "error" })),
+  import_effect2.Effect.catchTag(
+    "ParseError",
+    (e) => import_effect2.Effect.fail(import_schema.ArrayFormatter.formatErrorSync(e))
+  )
   // Effect.scoped
 );
-var kupmiosUtxosToUtxos = (kupoURL, utxos) => import_effect.Effect.forEach(
+var kupmiosUtxosToUtxos = (kupoURL, utxos) => import_effect2.Effect.forEach(
   utxos,
   (utxo) => {
-    return (0, import_effect.pipe)(
-      import_effect.Effect.all([
+    return (0, import_effect2.pipe)(
+      import_effect2.Effect.all([
         getDatumEffect(kupoURL, utxo.datum_type, utxo.datum_hash),
         getScriptEffect(kupoURL, utxo.script_hash)
       ]),
-      import_effect.Effect.map(
+      import_effect2.Effect.map(
         ([datum, script]) => ({
           txHash: utxo.transaction_id,
           outputIndex: utxo.output_index,
           address: utxo.address,
           assets: toAssets(utxo.value),
-          datumHash: utxo.datum_type === "hash" ? utxo.datum_hash : null,
+          datumHash: utxo.datum_type === "hash" ? utxo.datum_hash : void 0,
           datum,
           scriptRef: script
         })
@@ -1231,12 +1330,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;
     })();
@@ -1618,7 +1732,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;
@@ -1626,37 +1740,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) {
@@ -1839,10 +1955,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: (0, import_utils5.applyDoubleCborEncoding)(result.reference_script.bytes)
-      } : void 0
+      scriptRef: toScriptRef(result.reference_script)
     };
   }
   async getAllPagesData(getResponse, qry, paramsGiven, errorMsg) {
@@ -1893,6 +2006,29 @@ 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: (0, import_utils5.applyDoubleCborEncoding)(reference_script.bytes)
+        };
+      case "plutusv2":
+        return {
+          type: "PlutusV2",
+          script: (0, import_utils5.applyDoubleCborEncoding)(reference_script.bytes)
+        };
+      case "plutusv3":
+        return {
+          type: "PlutusV3",
+          script: (0, import_utils5.applyDoubleCborEncoding)(reference_script.bytes)
+        };
+      default:
+        return void 0;
+    }
+  }
+};
 var lucid2 = package_default.version;
 
 // src/koios/koios.ts
@@ -1903,6 +2039,28 @@ var import_utils6 = require("@lucid-evolution/utils");
 // src/koios/schema.ts
 var S3 = __toESM(require("@effect/schema/Schema"), 1);
 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,
@@ -1926,7 +2084,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,
@@ -1946,9 +2105,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),
@@ -1958,15 +2125,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(
@@ -1996,16 +2155,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,
@@ -2019,6 +2170,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),
@@ -2088,12 +2240,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
-var import_effect3 = require("effect");
-var import_schema2 = require("@effect/schema");
+var import_effect4 = require("effect");
+var import_schema3 = require("@effect/schema");
 
 // src/fetch.ts
 var fetch_exports = {};
@@ -2103,27 +2261,27 @@ __export(fetch_exports, {
   ResponseError: () => ResponseError,
   fetchEffect: () => fetchEffect
 });
-var import_effect2 = require("effect");
-var FetchError = class extends import_effect2.Data.TaggedError("FetchError") {
+var import_effect3 = require("effect");
+var FetchError = class extends import_effect3.Data.TaggedError("FetchError") {
 };
-var ResponseError = class extends import_effect2.Data.TaggedError("ResponseError") {
+var ResponseError = class extends import_effect3.Data.TaggedError("ResponseError") {
 };
-var JsonError = class extends import_effect2.Data.TaggedError("JsonError") {
+var JsonError = class extends import_effect3.Data.TaggedError("JsonError") {
 };
-var fetchEffect = (input, requestInit) => (0, import_effect2.pipe)(
-  import_effect2.Effect.tryPromise({
+var fetchEffect = (input, requestInit) => (0, import_effect3.pipe)(
+  import_effect3.Effect.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}.`
     })
   }),
-  import_effect2.Effect.flatMap(
+  import_effect3.Effect.flatMap(
     (response) => !response.ok ? new ResponseError({
       message: `${response.status} ${response.statusText}`
-    }) : import_effect2.Effect.succeed(response)
+    }) : import_effect3.Effect.succeed(response)
   ),
-  import_effect2.Effect.flatMap(
-    (response) => import_effect2.Effect.tryPromise({
+  import_effect3.Effect.flatMap(
+    (response) => import_effect3.Effect.tryPromise({
       try: () => response.json(),
       catch: (error) => new JsonError({ message: String(error) })
     })
@@ -2140,7 +2298,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 (0, import_effect4.pipe)(
+      S4.decodeUnknown(ProtocolParametersSchema2, {
+        onExcessProperty: "error",
+        errors: "first"
+      })(result[0]),
+      import_effect4.Effect.catchTag(
+        "ParseError",
+        (e) => import_effect4.Effect.fail(import_schema3.ArrayFormatter.formatErrorSync(e))
+      ),
+      import_effect4.Effect.runPromise
+    );
     return {
       minFeeA: param.min_fee_a,
       minFeeB: param.min_fee_b,
@@ -2167,6 +2335,12 @@ var Koios = class {
             index.toString(),
             value
           ])
+        ),
+        PlutusV3: Object.fromEntries(
+          param.cost_models.PlutusV3.map((value, index) => [
+            index.toString(),
+            value
+          ])
         )
       }
     };
@@ -2184,9 +2358,17 @@ var Koios = class {
         method: "POST",
         body: JSON.stringify(body)
       }).then((res) => res.json());
-      const parsedResult = S4.decodeUnknownSync(KoiosAddressInfoSchema)(
-        result
-      )[0];
+      const [parsedResult] = await (0, import_effect4.pipe)(
+        S4.decodeUnknown(KoiosAddressInfoSchema, {
+          onExcessProperty: "error",
+          errors: "first"
+        })(result),
+        import_effect4.Effect.catchTag(
+          "ParseError",
+          (e) => import_effect4.Effect.fail(import_schema3.ArrayFormatter.formatErrorSync(e))
+        ),
+        import_effect4.Effect.runPromise
+      );
       return parsedResult ? parsedResult.utxo_set.map(
         (koiosUTXO) => toUTxO(koiosUTXO, parsedResult.address)
       ) : [];
@@ -2235,9 +2417,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: {
@@ -2247,26 +2430,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 (0, import_effect4.pipe)(
+      S4.decodeUnknown(S4.Array(KoiosTxInfoSchema), {
+        onExcessProperty: "error",
+        errors: "first"
+      })(result),
+      import_effect4.Effect.catchTag(
+        "ParseError",
+        (e) => import_effect4.Effect.fail(import_schema3.ArrayFormatter.formatErrorSync(e))
+      ),
+      import_effect4.Effect.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 [];
     }
@@ -2322,24 +2518,24 @@ var Koios = class {
       method: "POST",
       body: JSON.stringify(body)
     };
-    const program = (0, import_effect3.pipe)(
+    const program = (0, import_effect4.pipe)(
       fetchEffect(`${this.baseUrl}/tx_info`, request),
-      import_effect3.Effect.flatMap(
+      import_effect4.Effect.flatMap(
         (json) => S4.decodeUnknown(S4.Array(KoiosTxInfoSchema))(json)
       ),
-      import_effect3.Effect.catchTag(
+      import_effect4.Effect.catchTag(
         "ParseError",
-        (e) => import_effect3.Effect.fail(import_schema2.ArrayFormatter.formatErrorSync(e))
+        (e) => import_effect4.Effect.fail(import_schema3.ArrayFormatter.formatErrorSync(e))
       ),
-      import_effect3.Effect.repeat({
-        schedule: import_effect3.Schedule.exponential(checkInterval),
+      import_effect4.Effect.repeat({
+        schedule: import_effect4.Schedule.exponential(checkInterval),
         until: (result) => result.length > 0
       }),
-      import_effect3.Effect.timeout(16e4),
-      import_effect3.Effect.orDie,
-      import_effect3.Effect.as(true)
+      import_effect4.Effect.timeout(16e4),
+      import_effect4.Effect.orDie,
+      import_effect4.Effect.as(true)
     );
-    return import_effect3.Effect.runPromise(program);
+    return import_effect4.Effect.runPromise(program);
   }
   async submitTx(tx) {
     const result = await fetch(`${this.baseUrl}/submittx`, {
@@ -2428,16 +2624,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: (0, import_utils6.applyDoubleCborEncoding)(koiosUTxO.reference_script.bytes)
-  } : {
-    type: "PlutusV2",
-    script: (0, import_utils6.applyDoubleCborEncoding)(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: (0, import_utils6.applyDoubleCborEncoding)(reference_script.bytes)
+        };
+      case "plutusV2":
+        return {
+          type: "PlutusV2",
+          script: (0, import_utils6.applyDoubleCborEncoding)(reference_script.bytes)
+        };
+      case "plutusV3":
+        return {
+          type: "PlutusV3",
+          script: (0, import_utils6.applyDoubleCborEncoding)(reference_script.bytes)
+        };
+      default:
+        return void 0;
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Blockfrost,