@lucid-evolution/provider 0.1.28 → 0.1.30

package/dist/index.js

@@ -1,3 +1,9 @@
+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";
 
@@ -8,7 +14,7 @@ import { applyDoubleCborEncoding } from "@lucid-evolution/utils";
 // package.json
 var package_default = {
   name: "@lucid-evolution/provider",
-  version: "0.1.28",
+  version: "0.1.30",
   description: "",
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
@@ -40,17 +46,18 @@ var package_default = {
   dependencies: {
     "@anastasia-labs/cardano-multiplatform-lib-browser": "^5.3.1-2",
     "@anastasia-labs/cardano-multiplatform-lib-nodejs": "^5.3.1-2",
-    "@effect/schema": "^0.67.16",
+    "@effect/platform": "^0.59.2",
+    "@effect/schema": "^0.68.26",
     "@lucid-evolution/core-types": "workspace:*",
     "@lucid-evolution/core-utils": "workspace:*",
     "@lucid-evolution/utils": "workspace:*",
-    effect: "^3.1.2"
+    effect: "^3.5.6"
   },
   devDependencies: {
     "@types/node": "^20.12.8",
     tsup: "^8.0.2",
     typescript: "^5.4.5",
-    vitest: "^1.6.0"
+    vitest: "^2.0.4"
   }
 };
 
@@ -309,232 +316,401 @@ function datumJsonToCbor(json) {
 }
 var lucid = package_default.version;
 
-// src/kupmios.ts
+// src/kupmios/kupmios.ts
 import { fromUnit } from "@lucid-evolution/utils";
+import * as S2 from "@effect/schema/Schema";
+import { Effect, pipe, Array as _Array, Schedule, Data } from "effect";
+
+// src/kupmios/schema.ts
+import * as S from "@effect/schema/Schema";
+var JSONRPCSchema = (schema) => S.extend(
+  S.Struct({
+    jsonrpc: S.Literal("2.0"),
+    method: S.String,
+    id: S.NullOr(S.Number)
+  }),
+  S.Union(S.Struct({ result: schema }), S.Struct({ error: S.Object }))
+);
+var LovelaceAsset = S.Struct({
+  lovelace: S.Number
+});
+var TupleNumberFromString = S.compose(
+  S.split("/"),
+  S.Array(S.NumberFromString)
+);
+var ProtocolParametersSchema = S.Struct({
+  minFeeCoefficient: S.Number,
+  minFeeConstant: S.Struct({ ada: LovelaceAsset }),
+  maxBlockBodySize: S.Struct({ bytes: S.Number }),
+  maxBlockHeaderSize: S.Struct({ bytes: S.Number }),
+  maxTransactionSize: S.Struct({ bytes: S.Number }),
+  stakeCredentialDeposit: S.Struct({ ada: LovelaceAsset }),
+  stakePoolDeposit: S.Struct({ ada: LovelaceAsset }),
+  stakePoolRetirementEpochBound: S.Number,
+  desiredNumberOfStakePools: S.Number,
+  stakePoolPledgeInfluence: TupleNumberFromString,
+  monetaryExpansion: TupleNumberFromString,
+  treasuryExpansion: TupleNumberFromString,
+  minStakePoolCost: S.Struct({ ada: LovelaceAsset }),
+  minUtxoDepositConstant: S.Struct({ ada: LovelaceAsset }),
+  minUtxoDepositCoefficient: S.Number,
+  plutusCostModels: S.Struct({
+    "plutus:v1": S.Array(S.Number),
+    "plutus:v2": S.Array(S.Number)
+  }),
+  scriptExecutionPrices: S.Struct({
+    memory: TupleNumberFromString,
+    cpu: TupleNumberFromString
+  }),
+  maxExecutionUnitsPerTransaction: S.Struct({
+    memory: S.Number,
+    cpu: S.Number
+  }),
+  maxExecutionUnitsPerBlock: S.Struct({ memory: S.Number, cpu: S.Number }),
+  maxValueSize: S.Struct({ bytes: S.Number }),
+  collateralPercentage: S.Number,
+  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 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
+  }),
+  spent_at: S.NullOr(S.Number)
+});
+var KupoScriptSchema = S.NullOr(
+  S.Struct({
+    language: S.Literal("native", "plutus:v1", "plutus:v2"),
+    script: S.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 }) })
+    })
+  )
+);
+
+// src/kupmios/kupmios.ts
+import {
+  HttpClient,
+  HttpClientRequest,
+  HttpClientResponse
+} from "@effect/platform";
+var KupmiosError = class extends Data.TaggedError("KupmiosError") {
+};
+var kupmiosError = (cause, method) => new KupmiosError({
+  cause,
+  message: `${method} failed: ${JSON.stringify(cause)}`
+});
 var Kupmios = class {
   kupoUrl;
   ogmiosUrl;
   /**
    * @param kupoUrl: http(s)://localhost:1442
-   * @param ogmiosUrl: ws(s)://localhost:1337
+   * @param ogmiosUrl: http(s)://localhost:1337
    */
   constructor(kupoUrl, ogmiosUrl) {
     this.kupoUrl = kupoUrl;
     this.ogmiosUrl = ogmiosUrl;
   }
   async getProtocolParameters() {
-    const client = await this.ogmiosWsp("queryLedgerState/protocolParameters");
-    return new Promise((res, rej) => {
-      client.addEventListener(
-        "message",
-        (msg) => {
-          try {
-            const { result } = JSON.parse(msg.data);
-            const costModels = {};
-            Object.keys(result.plutusCostModels).forEach((v) => {
-              const version = v.split(":")[1].toUpperCase();
-              const plutusVersion = "Plutus" + version;
-              costModels[plutusVersion] = result.plutusCostModels[v];
-            });
-            const [memNum, memDenom] = result.scriptExecutionPrices.memory.split("/");
-            const [stepsNum, stepsDenom] = result.scriptExecutionPrices.cpu.split("/");
-            res({
-              minFeeA: parseInt(result.minFeeCoefficient),
-              minFeeB: parseInt(result.minFeeConstant.ada.lovelace),
-              maxTxSize: parseInt(result.maxTransactionSize.bytes),
-              maxValSize: parseInt(result.maxValueSize.bytes),
-              keyDeposit: BigInt(result.stakeCredentialDeposit.ada.lovelace),
-              poolDeposit: BigInt(result.stakePoolDeposit.ada.lovelace),
-              priceMem: parseInt(memNum) / parseInt(memDenom),
-              priceStep: parseInt(stepsNum) / parseInt(stepsDenom),
-              maxTxExMem: BigInt(result.maxExecutionUnitsPerTransaction.memory),
-              maxTxExSteps: BigInt(result.maxExecutionUnitsPerTransaction.cpu),
-              // NOTE: coinsPerUtxoByte is now called utxoCostPerByte:
-              // https://github.com/IntersectMBO/cardano-node/pull/4141
-              // Ogmios v6.x calls it minUtxoDepositCoefficient according to the following
-              // documentation from its protocol parameters data model:
-              // https://github.com/CardanoSolutions/ogmios/blob/master/architectural-decisions/accepted/017-api-version-6-major-rewrite.md#protocol-parameters
-              coinsPerUtxoByte: BigInt(result.minUtxoDepositCoefficient),
-              collateralPercentage: parseInt(result.collateralPercentage),
-              maxCollateralInputs: parseInt(result.maxCollateralInputs),
-              costModels
-            });
-            client.close();
-          } catch (e) {
-            rej(e);
-          }
-        },
-        { once: true }
-      );
-    });
+    const data = {
+      jsonrpc: "2.0",
+      method: "queryLedgerState/protocolParameters",
+      params: {},
+      id: null
+    };
+    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)
+      ),
+      Effect.timeout(1e4),
+      Effect.catchAll(kupmiosError)
+    );
+    const result = await Effect.runPromise(program);
+    return toProtocolParameters(result);
   }
   async getUtxos(addressOrCredential) {
     const isAddress = typeof addressOrCredential === "string";
     const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
-    const result = await fetch(
-      `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent`
-    ).then((res) => res.json());
-    return this.kupmiosUtxosToUtxos(result);
+    const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent`;
+    const schema = S2.Array(KupoUTxO);
+    const program = fetchKupoParse(pattern, schema).pipe(
+      Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      Effect.timeout(1e4),
+      Effect.catchAll(kupmiosError)
+    );
+    const utxos = await Effect.runPromise(program);
+    return utxos;
   }
   async getUtxosWithUnit(addressOrCredential, unit) {
     const isAddress = typeof addressOrCredential === "string";
     const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
     const { policyId, assetName } = fromUnit(unit);
-    const result = await fetch(
-      `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&policy_id=${policyId}${assetName ? `&asset_name=${assetName}` : ""}`
-    ).then((res) => res.json());
-    return this.kupmiosUtxosToUtxos(result);
+    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(
+      Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      Effect.timeout(1e4),
+      Effect.catchAll(kupmiosError)
+    );
+    const utxos = await Effect.runPromise(program);
+    return utxos;
   }
   async getUtxoByUnit(unit) {
     const { policyId, assetName } = fromUnit(unit);
-    const result = await fetch(
-      `${this.kupoUrl}/matches/${policyId}.${assetName ? `${assetName}` : "*"}?unspent`
-    ).then((res) => res.json());
-    const utxos = await this.kupmiosUtxosToUtxos(result);
+    const pattern = `${this.kupoUrl}/matches/${policyId}.${assetName ? `${assetName}` : "*"}?unspent`;
+    const schema = S2.Array(KupoUTxO);
+    const program = fetchKupoParse(pattern, schema).pipe(
+      Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      Effect.timeout(1e4),
+      Effect.catchAll(kupmiosError)
+    );
+    const utxos = await Effect.runPromise(program);
     if (utxos.length > 1) {
       throw new Error("Unit needs to be an NFT or only held by one address.");
     }
     return utxos[0];
   }
   async getUtxosByOutRef(outRefs) {
-    const queryHashes = [...new Set(outRefs.map((outRef) => outRef.txHash))];
-    const utxos = await Promise.all(
-      queryHashes.map(async (txHash) => {
-        const result = await fetch(
-          `${this.kupoUrl}/matches/*@${txHash}?unspent`
-        ).then((res) => res.json());
-        return this.kupmiosUtxosToUtxos(result);
-      })
+    const queryHashes = [
+      ...new Set(outRefs.map((outRef) => outRef.txHash))
+    ];
+    const mkPattern = (txHash) => `${this.kupoUrl}/matches/*@${txHash}?unspent`;
+    const schema = S2.Array(KupoUTxO);
+    const program = Effect.forEach(
+      queryHashes,
+      (txHash) => fetchKupoParse(mkPattern(txHash), schema).pipe(
+        Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+        Effect.timeout(1e4),
+        Effect.catchAll(kupmiosError)
+      )
     );
-    return utxos.reduce((acc, utxos2) => acc.concat(utxos2), []).filter(
+    const utxos = await Effect.runPromise(program);
+    return _Array.flatten(utxos).filter(
       (utxo) => outRefs.some(
         (outRef) => utxo.txHash === outRef.txHash && utxo.outputIndex === outRef.outputIndex
       )
     );
   }
   async getDelegation(rewardAddress) {
-    const client = await this.ogmiosWsp(
-      "queryLedgerState/rewardAccountSummaries",
-      { keys: [rewardAddress] }
+    const data = {
+      jsonrpc: "2.0",
+      method: "queryLedgerState/rewardAccountSummaries",
+      params: { keys: [rewardAddress] },
+      id: null
+    };
+    const schema = JSONRPCSchema(KupoDelegation);
+    const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
+      Effect.flatMap(
+        (response) => "error" in response ? kupmiosError(response.error) : Effect.succeed(response.result)
+      ),
+      Effect.timeout(1e4),
+      Effect.catchAll(kupmiosError)
     );
-    return new Promise((res, rej) => {
-      client.addEventListener(
-        "message",
-        (msg) => {
-          try {
-            const { result } = JSON.parse(msg.data);
-            const delegation = result ? Object.values(result)[0] : {};
-            res({
-              poolId: delegation?.delegate?.id || null,
-              rewards: BigInt(delegation?.rewards?.ada?.lovelace || 0)
-            });
-            client.close();
-          } catch (e) {
-            rej(e);
-          }
-        },
-        { once: true }
-      );
-    });
+    const result = await Effect.runPromise(program);
+    const delegation = result ? Object.values(result)[0] : null;
+    return {
+      poolId: delegation?.delegate?.id || null,
+      rewards: BigInt(delegation?.rewards?.ada?.lovelace || 0)
+    };
   }
+  //TODO: add data validation
   async getDatum(datumHash) {
-    const result = await fetch(`${this.kupoUrl}/datums/${datumHash}`).then(
-      (res) => res.json()
+    const pattern = `${this.kupoUrl}/datums/${datumHash}`;
+    const schema = KupoDatumSchema;
+    const program = fetchKupoParse(pattern, schema).pipe(
+      Effect.timeout(1e4),
+      Effect.flatMap(Effect.fromNullable),
+      Effect.catchAll(kupmiosError)
     );
-    if (!result || !result.datum) {
-      throw new Error(`No datum found for datum hash: ${datumHash}`);
-    }
+    const result = await Effect.runPromise(program);
     return result.datum;
   }
-  awaitTx(txHash, checkInterval = 3e3) {
-    return new Promise((res) => {
-      const confirmation = setInterval(async () => {
-        const isConfirmed = await fetch(
-          `${this.kupoUrl}/matches/*@${txHash}?unspent`
-        ).then((res2) => res2.json());
-        if (isConfirmed && isConfirmed.length > 0) {
-          clearInterval(confirmation);
-          await new Promise((res2) => setTimeout(() => res2(1), 1e3));
-          return res(true);
-        }
-      }, checkInterval);
+  async awaitTx(txHash, checkInterval = 2e4) {
+    const pattern = `${this.kupoUrl}/matches/*@${txHash}?unspent`;
+    const schema = S2.Array(KupoUTxO).annotations({
+      identifier: "Array<KupmiosSchema.KupoUTxO>"
     });
+    const program = fetchKupoParse(pattern, schema).pipe(
+      Effect.repeat({
+        schedule: Schedule.exponential(checkInterval),
+        until: (result) => result.length > 0
+      }),
+      Effect.timeout(16e4),
+      Effect.catchAll(kupmiosError),
+      Effect.as(true)
+    );
+    return await Effect.runPromise(program);
   }
   async submitTx(cbor) {
-    const client = await this.ogmiosWsp("submitTransaction", {
-      transaction: { cbor }
-    });
-    return new Promise((res, rej) => {
-      client.addEventListener(
-        "message",
-        (msg) => {
-          try {
-            const { result } = JSON.parse(msg.data);
-            if (result.transaction) res(result.transaction.id);
-            else rej(result.error);
-            client.close();
-          } catch (e) {
-            rej(e);
-          }
-        },
-        { once: true }
-      );
-    });
-  }
-  kupmiosUtxosToUtxos(utxos) {
-    return Promise.all(
-      utxos.map(async (utxo) => {
-        return {
-          txHash: utxo.transaction_id,
-          outputIndex: parseInt(utxo.output_index),
-          address: utxo.address,
-          assets: (() => {
-            const a = { lovelace: BigInt(utxo.value.coins) };
-            Object.keys(utxo.value.assets).forEach((unit) => {
-              a[unit.replace(".", "")] = BigInt(utxo.value.assets[unit]);
-            });
-            return a;
-          })(),
-          datumHash: utxo?.datum_type === "hash" ? utxo.datum_hash : null,
-          datum: utxo?.datum_type === "inline" ? await this.getDatum(utxo.datum_hash) : null,
-          scriptRef: utxo.script_hash && await (async () => {
-            const { script, language } = await fetch(
-              `${this.kupoUrl}/scripts/${utxo.script_hash}`
-            ).then((res) => res.json());
-            if (language === "native") {
-              return { type: "Native", script };
-            } else if (language === "plutus:v1") {
-              return {
-                type: "PlutusV1",
-                script: CML.PlutusV1Script.from_cbor_hex(script).to_cbor_hex()
-              };
-            } else if (language === "plutus:v2") {
-              return {
-                type: "PlutusV2",
-                script: CML.PlutusV2Script.from_cbor_hex(script).to_cbor_hex()
-              };
-            }
-          })()
-        };
+    const data = {
+      jsonrpc: "2.0",
+      method: "submitTransaction",
+      params: {
+        transaction: { cbor }
+      },
+      id: null
+    };
+    const schema = JSONRPCSchema(
+      S2.Struct({
+        transaction: S2.Struct({
+          id: S2.String
+        })
       })
     );
+    const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
+      Effect.flatMap(
+        (response) => "error" in response ? Effect.fail(response.error) : Effect.succeed(response)
+      ),
+      Effect.timeout(1e4),
+      Effect.catchAll((cause) => kupmiosError(cause, "submitTx"))
+    );
+    const { result } = await Effect.runPromise(program);
+    return result.transaction.id;
   }
-  async ogmiosWsp(method, params = {}, id) {
-    const client = new WebSocket(this.ogmiosUrl);
-    await new Promise((res) => {
-      client.addEventListener("open", () => res(1), { once: true });
-    });
-    client.send(
-      JSON.stringify({
-        jsonrpc: "2.0",
-        method,
-        params,
-        id
+};
+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;
+    return yield* fetchKupoParse(pattern, schema).pipe(
+      Effect.flatMap(Effect.fromNullable),
+      Effect.map((result) => result.datum),
+      Effect.timeout(1e4)
+    );
+  } else return null;
+});
+var getScriptEffect = (kupoUrl, script_hash) => Effect.gen(function* () {
+  if (script_hash) {
+    const pattern = `${kupoUrl}/scripts/${script_hash}`;
+    const schema = KupoScriptSchema;
+    return yield* pipe(
+      fetchKupoParse(pattern, schema),
+      Effect.flatMap(Effect.fromNullable),
+      Effect.timeout(1e4),
+      Effect.map(({ language, script }) => {
+        switch (language) {
+          case "native":
+            return { type: "Native", script };
+          case "plutus:v1":
+            return { type: "PlutusV1", script };
+          case "plutus:v2":
+            return { type: "PlutusV2", script };
+        }
       })
     );
-    return client;
+  } else return null;
+});
+var toAssets = (value) => {
+  const assets = { lovelace: BigInt(value.coins) };
+  for (const unit of Object.keys(value.assets)) {
+    assets[unit.replace(".", "")] = BigInt(value.assets[unit]);
   }
+  return assets;
+};
+var toProtocolParameters = (result) => {
+  return {
+    minFeeA: result.minFeeCoefficient,
+    minFeeB: result.minFeeConstant.ada.lovelace,
+    maxTxSize: result.maxTransactionSize.bytes,
+    maxValSize: result.maxValueSize.bytes,
+    keyDeposit: BigInt(result.stakeCredentialDeposit.ada.lovelace),
+    poolDeposit: BigInt(result.stakePoolDeposit.ada.lovelace),
+    priceMem: result.scriptExecutionPrices.memory[0] / result.scriptExecutionPrices.memory[1],
+    priceStep: result.scriptExecutionPrices.cpu[0] / result.scriptExecutionPrices.cpu[1],
+    maxTxExMem: BigInt(result.maxExecutionUnitsPerTransaction.memory),
+    maxTxExSteps: BigInt(result.maxExecutionUnitsPerTransaction.cpu),
+    // NOTE: coinsPerUtxoByte is now called utxoCostPerByte:
+    // https://github.com/IntersectMBO/cardano-node/pull/4141
+    // Ogmios v6.x calls it minUtxoDepositCoefficient according to the following
+    // documentation from its protocol parameters data model:
+    // https://github.com/CardanoSolutions/ogmios/blob/master/architectural-decisions/accepted/017-api-version-6-major-rewrite.md#protocol-parameters
+    coinsPerUtxoByte: BigInt(result.minUtxoDepositCoefficient),
+    collateralPercentage: result.collateralPercentage,
+    maxCollateralInputs: result.maxCollateralInputs,
+    costModels: {
+      PlutusV1: Object.fromEntries(
+        result.plutusCostModels["plutus:v1"].map((value, index) => [
+          index.toString(),
+          value
+        ])
+      ),
+      PlutusV2: Object.fromEntries(
+        result.plutusCostModels["plutus:v2"].map((value, index) => [
+          index.toString(),
+          value
+        ])
+      )
+    }
+  };
 };
+var fetchOgmiosParse = (url, data, schema) => pipe(
+  HttpClientRequest.post(url),
+  HttpClientRequest.jsonBody(data),
+  Effect.flatMap(HttpClient.fetchOk),
+  HttpClientResponse.json,
+  Effect.flatMap(S2.decodeUnknown(schema))
+  // Effect.catchTag("ParseError", (e) =>
+  //   Effect.fail(ArrayFormatter.formatIssueSync(e.issue)),
+  // ),
+  // Effect.scoped
+);
+var fetchKupoParse = (url, schema) => pipe(
+  HttpClientRequest.get(url),
+  HttpClient.fetchOk,
+  HttpClientResponse.json,
+  Effect.flatMap(S2.decodeUnknown(schema))
+  // Effect.catchTag("ParseError", (e) =>
+  //   Effect.fail(ArrayFormatter.formatIssueSync(e.issue)),
+  // ),
+  // Effect.scoped
+);
+var kupmiosUtxosToUtxos = (kupoURL, utxos) => Effect.forEach(
+  utxos,
+  (utxo) => {
+    return pipe(
+      Effect.all([
+        getDatumEffect(kupoURL, utxo.datum_type, utxo.datum_hash),
+        getScriptEffect(kupoURL, utxo.script_hash)
+      ]),
+      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,
+          datum,
+          scriptRef: script
+        })
+      )
+    );
+  },
+  { concurrency: "unbounded" }
+);
 
 // src/maestro.ts
 import { applyDoubleCborEncoding as applyDoubleCborEncoding2 } from "@lucid-evolution/utils";
@@ -800,194 +976,194 @@ var Maestro = class {
 var lucid2 = package_default.version;
 
 // src/koios/koios.ts
-import * as S2 from "@effect/schema/Schema";
+import * as S4 from "@effect/schema/Schema";
 import { fromHex as fromHex3 } from "@lucid-evolution/core-utils";
 import { applyDoubleCborEncoding as applyDoubleCborEncoding3, fromUnit as fromUnit2 } from "@lucid-evolution/utils";
 
 // src/koios/schema.ts
-import * as S from "@effect/schema/Schema";
-var ProtocolParametersSchema = S.Struct({
-  epoch_no: S.Number,
-  min_fee_a: S.Number,
-  min_fee_b: S.Number,
-  max_block_size: S.Number,
-  max_tx_size: S.Number,
-  max_bh_size: S.Number,
-  key_deposit: S.BigInt,
-  pool_deposit: S.BigInt,
-  max_epoch: S.Number,
-  optimal_pool_count: S.Number,
-  influence: S.Number,
-  monetary_expand_rate: S.Number,
-  treasury_growth_rate: S.Number,
-  decentralisation: S.Number,
-  extra_entropy: S.NullOr(S.String),
-  protocol_major: S.Number,
-  protocol_minor: S.Number,
-  min_utxo_value: S.String,
-  min_pool_cost: S.String,
-  nonce: S.String,
-  block_hash: S.NullOr(S.String),
-  cost_models: S.Struct({
-    PlutusV1: S.Array(S.Number),
-    PlutusV2: S.Array(S.Number)
+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)
   }),
-  price_mem: S.Number,
-  price_step: S.Number,
-  max_tx_ex_mem: S.BigIntFromNumber,
-  max_tx_ex_steps: S.BigIntFromNumber,
-  max_block_ex_mem: S.Number,
-  max_block_ex_steps: S.Number,
-  max_val_size: S.Number,
-  collateral_percent: S.Number,
-  max_collateral_inputs: S.Number,
-  coins_per_utxo_size: S.BigInt
+  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
 });
-var KoiosAssetSchema = S.Struct({
-  policy_id: S.String,
-  asset_name: S.NullOr(S.String),
-  fingerprint: S.String,
-  decimals: S.Number,
-  quantity: S.String
+var KoiosAssetSchema = S3.Struct({
+  policy_id: S3.String,
+  asset_name: S3.NullOr(S3.String),
+  fingerprint: S3.String,
+  decimals: S3.Number,
+  quantity: S3.String
 });
-var KoiosUTxOSchema = S.Struct({
-  tx_hash: S.String,
-  tx_index: S.Number,
-  block_height: S.NullOr(S.Number),
-  value: S.String,
-  datum_hash: S.NullOr(S.String),
-  inline_datum: S.NullOr(
-    S.Struct({
-      bytes: S.String,
-      value: S.Object
+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: S.NullOr(
-    S.Struct({
-      hash: S.String,
-      size: S.Number,
-      type: S.String,
-      bytes: S.String,
-      value: S.NullOr(S.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: S.NullOr(S.Array(KoiosAssetSchema))
+  asset_list: S3.NullOr(S3.Array(KoiosAssetSchema))
 });
-var KoiosAddressInfoSchema = S.Array(
-  S.NullishOr(
-    S.Struct({
-      address: S.String,
-      balance: S.String,
-      stake_address: S.NullOr(S.String),
-      script_address: S.Boolean,
-      utxo_set: S.Array(KoiosUTxOSchema)
+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 KoiosInputOutputSchema = S.Struct({
-  payment_addr: S.Struct({
-    bech32: S.String,
-    cred: S.String
+var KoiosInputOutputSchema = S3.Struct({
+  payment_addr: S3.Struct({
+    bech32: S3.String,
+    cred: S3.String
   }),
-  stake_addr: S.NullOr(S.String),
-  tx_hash: S.String,
-  tx_index: S.Number,
-  value: S.String,
-  datum_hash: S.NullOr(S.String),
-  inline_datum: S.NullOr(
-    S.Struct({
-      bytes: S.String,
-      value: S.Object
+  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: S.NullOr(
-    S.Struct({
-      hash: S.String,
-      size: S.Number,
-      type: S.String,
-      bytes: S.String,
-      value: S.NullOr(S.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: S.Union(S.Array(KoiosAssetSchema), S.String)
+  asset_list: S3.Union(S3.Array(KoiosAssetSchema), S3.String)
 });
-var KoiosTxInfoSchema = S.Struct({
-  tx_hash: S.String,
-  block_hash: S.String,
-  block_height: S.Number,
-  epoch_no: S.Number,
-  epoch_slot: S.Number,
-  absolute_slot: S.Number,
-  tx_timestamp: S.Number,
-  tx_block_index: S.Number,
-  tx_size: S.Number,
-  total_output: S.String,
-  fee: S.String,
-  deposit: S.String,
-  invalid_before: S.NullOr(S.String),
-  invalid_after: S.NullOr(S.String),
-  collateral_inputs: S.NullOr(S.Array(KoiosInputOutputSchema)),
-  collateral_output: S.NullOr(KoiosInputOutputSchema),
-  reference_inputs: S.NullOr(S.Array(KoiosInputOutputSchema)),
-  inputs: S.Array(KoiosInputOutputSchema),
-  outputs: S.Array(KoiosInputOutputSchema),
-  withdrawals: S.NullOr(
-    S.Array(
-      S.Struct({
-        amount: S.String,
-        stake_addr: S.String
+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
       })
     )
   ),
-  assets_minted: S.NullOr(S.Array(KoiosAssetSchema)),
-  metadata: S.NullOr(S.Object),
-  certificates: S.NullOr(
-    S.Array(
-      S.Struct({
-        index: S.Number,
-        type: S.String,
-        info: S.NullOr(S.Object)
+  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)
       })
     )
   ),
-  native_scripts: S.NullOr(
-    S.Array(
-      S.Struct({
-        script_hash: S.String,
-        script_json: S.Object
+  native_scripts: S3.NullOr(
+    S3.Array(
+      S3.Struct({
+        script_hash: S3.String,
+        script_json: S3.Object
       })
     )
   ),
-  plutus_contracts: S.NullOr(
-    S.Array(
-      S.Struct({
-        address: S.String,
-        spends_input: S.NullOr(
-          S.Struct({
-            tx_hash: S.String,
-            tx_index: S.Number
+  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
           })
         ),
-        script_hash: S.String,
-        bytecode: S.String,
-        size: S.Number,
-        valid_contract: S.Boolean,
-        input: S.Struct({
-          redeemer: S.Struct({
-            purpose: S.Literal("spend", "mint", "cert", "reward"),
-            fee: S.String,
-            unit: S.Struct({
-              steps: S.String,
-              mem: S.String
+        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
             }),
-            datum: S.Struct({
-              hash: S.NullOr(S.String),
-              value: S.NullOr(S.Object)
+            datum: S3.Struct({
+              hash: S3.NullOr(S3.String),
+              value: S3.NullOr(S3.Object)
             })
           }),
-          datum: S.Struct({
-            hash: S.NullOr(S.String),
-            value: S.NullOr(S.Object)
+          datum: S3.Struct({
+            hash: S3.NullOr(S3.String),
+            value: S3.NullOr(S3.Object)
           })
         })
       })
@@ -996,8 +1172,45 @@ var KoiosTxInfoSchema = S.Struct({
 });
 
 // src/koios/koios.ts
-import { Effect, pipe, Schedule } from "effect";
+import { Effect as Effect3, pipe as pipe3, 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
+});
+import { Data as Data2, Effect as Effect2, pipe as pipe2 } 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(
+  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
 var Koios = class {
   baseUrl;
   constructor(baseUrl) {
@@ -1007,7 +1220,7 @@ var Koios = class {
     const result = await fetch(`${this.baseUrl}/epoch_params?limit=1`).then(
       (res) => res.json()
     );
-    const param = S2.decodeUnknownSync(ProtocolParametersSchema)(result[0]);
+    const param = S4.decodeUnknownSync(ProtocolParametersSchema2)(result[0]);
     return {
       minFeeA: param.min_fee_a,
       minFeeB: param.min_fee_b,
@@ -1051,7 +1264,7 @@ var Koios = class {
         method: "POST",
         body: JSON.stringify(body)
       }).then((res) => res.json());
-      const parsedResult = S2.decodeUnknownSync(KoiosAddressInfoSchema)(
+      const parsedResult = S4.decodeUnknownSync(KoiosAddressInfoSchema)(
         result
       )[0];
       return parsedResult ? parsedResult.utxo_set.map(
@@ -1114,7 +1327,7 @@ var Koios = class {
       method: "POST",
       body: JSON.stringify(body)
     }).then((res) => res.json());
-    const parsedResult = S2.decodeUnknownSync(S2.Array(KoiosTxInfoSchema))(
+    const parsedResult = S4.decodeUnknownSync(S4.Array(KoiosTxInfoSchema))(
       result
     )[0];
     if (parsedResult) {
@@ -1177,7 +1390,7 @@ var Koios = class {
       throw new Error("No Datum Found by Datum Hash");
     }
   }
-  awaitTx(txHash, checkInterval = 2e4) {
+  async awaitTx(txHash, checkInterval = 2e4) {
     const body = {
       _tx_hashes: [txHash]
     };
@@ -1189,36 +1402,24 @@ var Koios = class {
       method: "POST",
       body: JSON.stringify(body)
     };
-    const program = pipe(
-      Effect.tryPromise({
-        //TODO: use tx_status api
-        try: () => fetch(`${this.baseUrl}/tx_info`, request),
-        catch: (error) => new Error(String(error))
-      }),
-      Effect.flatMap(
-        (response) => !response.ok ? Effect.fail(new Error(`${response.status} ${response.statusText}`)) : Effect.succeed(response)
+    const program = pipe3(
+      fetchEffect(`${this.baseUrl}/tx_info`, request),
+      Effect3.flatMap(
+        (json) => S4.decodeUnknown(S4.Array(KoiosTxInfoSchema))(json)
       ),
-      Effect.flatMap(
-        (response) => Effect.tryPromise({
-          try: () => response.json(),
-          catch: (error) => new Error(String(error))
-        })
-      ),
-      Effect.flatMap(
-        (json) => S2.decodeUnknown(S2.Array(KoiosTxInfoSchema), { errors: "first" })(json)
-      ),
-      Effect.catchTag(
+      Effect3.catchTag(
         "ParseError",
-        (e) => Effect.fail(ArrayFormatter.formatErrorSync(e))
+        (e) => Effect3.fail(ArrayFormatter.formatErrorSync(e))
       ),
-      Effect.repeat({
-        schedule: Schedule.exponential(checkInterval),
+      Effect3.repeat({
+        schedule: Schedule2.exponential(checkInterval),
         until: (result) => result.length > 0
       }),
-      Effect.orDie,
-      Effect.as(true)
+      Effect3.timeout(16e4),
+      Effect3.orDie,
+      Effect3.as(true)
     );
-    return Effect.runPromise(program);
+    return Effect3.runPromise(program);
   }
   async submitTx(tx) {
     const result = await fetch(`${this.baseUrl}/submittx`, {
@@ -1229,8 +1430,8 @@ var Koios = class {
       method: "POST",
       body: fromHex3(tx)
     }).then((res) => res.json());
-    const TxHashSchema = S2.String;
-    const isTxHash = S2.is(TxHashSchema);
+    const TxHashSchema = S4.String;
+    const isTxHash = S4.is(TxHashSchema);
     if (!isTxHash(result)) {
       throw new Error(JSON.stringify(result));
     }
@@ -1263,8 +1464,10 @@ var toUTxO = (koiosUTxO, address) => ({
 });
 export {
   Blockfrost,
+  fetch_exports as FetchProvider,
   Koios,
   Kupmios,
+  KupmiosError,
   Maestro,
   datumJsonToCbor
 };