@lucid-evolution/provider 0.1.82 → 0.1.84

package/dist/index.js

@@ -11,7 +11,7 @@ import {
 // package.json
 var package_default = {
   name: "@lucid-evolution/provider",
-  version: "0.1.82",
+  version: "0.1.84",
   description: "",
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
@@ -43,13 +43,13 @@ var package_default = {
   dependencies: {
     "@anastasia-labs/cardano-multiplatform-lib-browser": "6.0.2-3",
     "@anastasia-labs/cardano-multiplatform-lib-nodejs": "6.0.2-3",
-    "@effect/platform": "^0.59.2",
+    "@effect/platform": "^0.71.3",
     "@effect/schema": "^0.68.26",
     "@lucid-evolution/core-types": "workspace:*",
     "@lucid-evolution/core-utils": "workspace:*",
     "@lucid-evolution/utils": "workspace:*",
     "@lucid-evolution/wallet": "workspace:*",
-    effect: "^3.10.4"
+    effect: "^3.11.7"
   },
   devDependencies: {
     "@types/node": "^20.12.8",
@@ -411,26 +411,18 @@ var lucid = package_default.version;
 
 // src/kupmios.ts
 import { applyDoubleCborEncoding as applyDoubleCborEncoding2, fromUnit as fromUnit2 } from "@lucid-evolution/utils";
-import * as S3 from "@effect/schema/Schema";
-import { Effect, pipe as pipe2, Array as _Array, Schedule, Data } from "effect";
-import {
-  HttpClient,
-  HttpClientRequest,
-  HttpClientResponse
-} from "@effect/platform";
-import { ArrayFormatter } from "@effect/schema";
+import { Schema as S3 } from "effect";
+import { Effect as Effect2, pipe as pipe3, Array as _Array, Schedule, Data } from "effect";
 
 // src/internal/ogmios.ts
-import * as S from "@effect/schema/Schema";
+import { Schema as S } from "effect";
 import { applySingleCborEncoding as applySingleCborEncoding2, fromUnit } from "@lucid-evolution/utils";
-var JSONRPCSchema = (schema) => S.extend(
-  S.Struct({
-    jsonrpc: S.String,
-    method: S.optional(S.String),
-    id: S.NullOr(S.Number)
-  }),
-  S.Union(S.Struct({ result: schema }), S.Struct({ error: S.Object }))
-);
+var JSONRPCSchema = (schema) => S.Struct({
+  jsonrpc: S.String,
+  method: S.optional(S.String),
+  id: S.NullOr(S.Number),
+  result: schema
+}).annotations({ identifier: "JSONRPCSchema" });
 var LovelaceAsset = S.Struct({
   lovelace: S.Number
 });
@@ -517,16 +509,16 @@ var ProtocolParametersSchema = S.Struct({
   collateralPercentage: S.Number,
   maxCollateralInputs: S.Number,
   version: S.Struct({ major: S.Number, minor: S.Number })
-});
+}).annotations({ identifier: "ProtocolParametersSchema" });
 var Delegation = S.NullOr(
-  S.Record(
-    S.String,
-    S.Struct({
+  S.Record({
+    key: S.String,
+    value: S.Struct({
       delegate: S.Struct({ id: S.String }),
       rewards: S.Struct({ ada: S.Struct({ lovelace: S.Number }) }),
       deposit: S.Struct({ ada: S.Struct({ lovelace: S.Number }) })
     })
-  )
+  })
 );
 var RedeemerSchema = S.Struct({
   validator: S.Struct({
@@ -544,7 +536,7 @@ var RedeemerSchema = S.Struct({
     memory: S.Int,
     cpu: S.Int
   })
-});
+}).annotations({ identifier: "RedeemerSchema" });
 var toOgmiosUTxOs = (utxos) => {
   const toOgmiosScript = (scriptRef) => {
     if (scriptRef) {
@@ -600,10 +592,10 @@ var toOgmiosUTxOs = (utxos) => {
 };
 
 // src/internal/kupo.ts
-import * as S2 from "@effect/schema/Schema";
+import { Schema as S2 } from "effect";
 var ValueSchema = S2.Struct({
   coins: S2.Number,
-  assets: S2.Record(S2.String, S2.Number)
+  assets: S2.Record({ key: S2.String, value: S2.Number })
 });
 var UTxOSchema = S2.Struct({
   transaction_index: S2.Number,
@@ -633,32 +625,104 @@ var ScriptSchema = S2.NullOr(
 );
 var DatumSchema = S2.NullOr(S2.Struct({ datum: S2.String }));
 var DelegationSchema = S2.NullOr(
-  S2.Record(
-    S2.String,
-    S2.Struct({
+  S2.Record({
+    key: S2.String,
+    value: S2.Struct({
       delegate: S2.Struct({ id: S2.String }),
       rewards: S2.Struct({ ada: S2.Struct({ lovelace: S2.Number }) }),
       deposit: S2.Struct({ ada: S2.Struct({ lovelace: S2.Number }) })
     })
+  })
+);
+
+// src/internal/HttpUtils.ts
+import {
+  HttpClient,
+  HttpClientError,
+  HttpClientRequest,
+  HttpClientResponse
+} from "@effect/platform";
+import { Effect, identity, pipe as pipe2 } from "effect";
+var filterStatusOk = (self) => self.status >= 200 && self.status < 300 ? Effect.succeed(self) : self.text.pipe(
+  Effect.flatMap(
+    (text) => Effect.fail(
+      new HttpClientError.ResponseError({
+        response: self,
+        request: self.request,
+        reason: "StatusCode",
+        description: `non 2xx status code : ${text}`
+      })
+    )
   )
 );
+var makeGet = (url, schema, headers) => pipe2(
+  // Initiate a GET request to the specified URL
+  HttpClientRequest.get(url),
+  // Conditional bearer token authentication
+  headers ? HttpClientRequest.setHeaders(headers) : identity,
+  // Execute the HTTP request and retrieve the response
+  HttpClient.execute,
+  // Ensure only 2xx responses are treated as successes.
+  Effect.flatMap(filterStatusOk),
+  // Parse the response body using the provided JSON schema
+  // This validates and transforms the response to the expected type
+  Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)),
+  // Ensure request is aborted if the program is interrupted
+  // Prevents resource leaks and ensures clean request termination
+  Effect.scoped
+);
+var makePostAsJson = (url, data, schema, headers) => pipe2(
+  // Initiate a POST request to the specified URL
+  HttpClientRequest.post(url),
+  // Conditional headers
+  headers ? HttpClientRequest.setHeaders(headers) : identity,
+  // Set the request body as Json
+  HttpClientRequest.bodyJson(data),
+  // Execute the HTTP request and retrieve the response
+  Effect.flatMap(HttpClient.execute),
+  // Ensure only 2xx responses are treated as successes.
+  Effect.flatMap(filterStatusOk),
+  // Parse the response body using the provided JSON schema
+  // This validates and transforms the response to the expected type
+  Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)),
+  // Ensure request is aborted if the program is interrupted
+  // Prevents resource leaks and ensures clean request termination
+  Effect.scoped
+);
+var makePostAsUint8Array = (url, data, schema, headers) => pipe2(
+  // Initiate a POST request to the specified URL
+  HttpClientRequest.post(url),
+  // Conditional bearer token authentication
+  headers ? HttpClientRequest.setHeaders(headers) : identity,
+  // Set the request body as a Uint8Array with CBOR content type
+  HttpClientRequest.bodyUint8Array(data, "application/cbor"),
+  // Execute the HTTP request and retrieve the response
+  HttpClient.execute,
+  // Ensure only 2xx responses are treated as successes.
+  Effect.flatMap(filterStatusOk),
+  // Parse the response body using the provided JSON schema
+  // This validates and transforms the response to the expected type
+  Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)),
+  // Ensure request is aborted if the program is interrupted
+  // Prevents resource leaks and ensures clean request termination
+  Effect.scoped
+);
 
 // src/kupmios.ts
+import { FetchHttpClient } from "@effect/platform";
 var KupmiosError = class extends Data.TaggedError("KupmiosError") {
   get message() {
-    return `${JSON.stringify(this.cause)}`;
+    return `${this.cause}`;
   }
 };
 var Kupmios = class {
   kupoUrl;
   ogmiosUrl;
-  /**
-   * @param kupoUrl: http(s)://localhost:1442
-   * @param ogmiosUrl: http(s)://localhost:1337
-   */
-  constructor(kupoUrl, ogmiosUrl) {
+  headers;
+  constructor(kupoUrl, ogmiosUrl, headers) {
     this.kupoUrl = kupoUrl;
     this.ogmiosUrl = ogmiosUrl;
+    this.headers = headers;
   }
   async getProtocolParameters() {
     const data = {
@@ -668,14 +732,18 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCSchema(ProtocolParametersSchema);
-    const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      Effect.flatMap(
-        (response) => "error" in response ? Effect.fail(response) : Effect.succeed(response.result)
+    const { result } = await pipe3(
+      makePostAsJson(
+        this.ogmiosUrl,
+        data,
+        schema,
+        this.headers?.ogmiosHeader
       ),
-      Effect.timeout(1e4),
-      Effect.catchAll((cause) => new KupmiosError({ cause }))
+      Effect2.timeout(1e4),
+      Effect2.catchAll((cause) => new KupmiosError({ cause })),
+      Effect2.provide(FetchHttpClient.layer),
+      Effect2.runPromise
     );
-    const result = await Effect.runPromise(program);
     return toProtocolParameters(result);
   }
   async getUtxos(addressOrCredential) {
@@ -683,12 +751,14 @@ var Kupmios = class {
     const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
     const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent`;
     const schema = S3.Array(UTxOSchema);
-    const program = fetchKupoParse(pattern, schema).pipe(
-      Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-      Effect.timeout(1e4),
-      Effect.catchAll((cause) => new KupmiosError({ cause }))
+    const utxos = await pipe3(
+      makeGet(pattern, schema, this.headers?.kupoHeader),
+      Effect2.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      Effect2.timeout(1e4),
+      Effect2.catchAll((cause) => new KupmiosError({ cause })),
+      Effect2.provide(FetchHttpClient.layer),
+      Effect2.runPromise
     );
-    const utxos = await Effect.runPromise(program);
     return utxos;
   }
   async getUtxosWithUnit(addressOrCredential, unit) {
@@ -697,24 +767,28 @@ var Kupmios = class {
     const { policyId, assetName } = fromUnit2(unit);
     const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&policy_id=${policyId}${assetName ? `&asset_name=${assetName}` : ""}`;
     const schema = S3.Array(UTxOSchema);
-    const program = fetchKupoParse(pattern, schema).pipe(
-      Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-      Effect.timeout(1e4),
-      Effect.catchAll((cause) => new KupmiosError({ cause }))
+    const utxos = await pipe3(
+      makeGet(pattern, schema, this.headers?.kupoHeader),
+      Effect2.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      Effect2.timeout(1e4),
+      Effect2.catchAll((cause) => new KupmiosError({ cause })),
+      Effect2.provide(FetchHttpClient.layer),
+      Effect2.runPromise
     );
-    const utxos = await Effect.runPromise(program);
     return utxos;
   }
   async getUtxoByUnit(unit) {
     const { policyId, assetName } = fromUnit2(unit);
     const pattern = `${this.kupoUrl}/matches/${policyId}.${assetName ? `${assetName}` : "*"}?unspent`;
     const schema = S3.Array(UTxOSchema);
-    const program = fetchKupoParse(pattern, schema).pipe(
-      Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-      Effect.timeout(1e4),
-      Effect.catchAll((cause) => new KupmiosError({ cause }))
+    const utxos = await pipe3(
+      makeGet(pattern, schema, this.headers?.kupoHeader),
+      Effect2.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      Effect2.timeout(1e4),
+      Effect2.catchAll((cause) => new KupmiosError({ cause })),
+      Effect2.provide(FetchHttpClient.layer),
+      Effect2.runPromise
     );
-    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.");
     }
@@ -726,15 +800,18 @@ var Kupmios = class {
     ];
     const mkPattern = (txHash) => `${this.kupoUrl}/matches/*@${txHash}?unspent`;
     const schema = S3.Array(UTxOSchema);
-    const program = Effect.forEach(
+    const program = Effect2.forEach(
       queryHashes,
-      (txHash) => fetchKupoParse(mkPattern(txHash), schema).pipe(
-        Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-        Effect.timeout(1e4),
-        Effect.catchAll((cause) => new KupmiosError({ cause }))
+      (txHash) => pipe3(
+        makeGet(mkPattern(txHash), schema, this.headers?.kupoHeader),
+        Effect2.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+        Effect2.timeout(1e4),
+        Effect2.catchAll((cause) => new KupmiosError({ cause }))
       )
     );
-    const utxos = await Effect.runPromise(program);
+    const utxos = await Effect2.runPromise(
+      pipe3(program, Effect2.provide(FetchHttpClient.layer))
+    );
     return _Array.flatten(utxos).filter(
       (utxo) => outRefs.some(
         (outRef) => utxo.txHash === outRef.txHash && utxo.outputIndex === outRef.outputIndex
@@ -749,14 +826,18 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCSchema(Delegation);
-    const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      Effect.flatMap(
-        (response) => "error" in response ? Effect.fail(response) : Effect.succeed(response.result)
+    const { result } = await pipe3(
+      makePostAsJson(
+        this.ogmiosUrl,
+        data,
+        schema,
+        this.headers?.ogmiosHeader
       ),
-      Effect.timeout(1e4),
-      Effect.catchAll((cause) => new KupmiosError({ cause }))
+      Effect2.provide(FetchHttpClient.layer),
+      Effect2.timeout(1e4),
+      Effect2.catchAll((cause) => new KupmiosError({ cause })),
+      Effect2.runPromise
     );
-    const result = await Effect.runPromise(program);
     const delegation = result ? Object.values(result)[0] : null;
     return {
       poolId: delegation?.delegate?.id || null,
@@ -766,12 +847,14 @@ var Kupmios = class {
   async getDatum(datumHash) {
     const pattern = `${this.kupoUrl}/datums/${datumHash}`;
     const schema = DatumSchema;
-    const program = fetchKupoParse(pattern, schema).pipe(
-      Effect.timeout(1e4),
-      Effect.flatMap(Effect.fromNullable),
-      Effect.catchAll((cause) => new KupmiosError({ cause }))
+    const result = await pipe3(
+      makeGet(pattern, schema, this.headers?.kupoHeader),
+      Effect2.provide(FetchHttpClient.layer),
+      Effect2.timeout(1e4),
+      Effect2.flatMap(Effect2.fromNullable),
+      Effect2.catchAll((cause) => new KupmiosError({ cause })),
+      Effect2.runPromise
     );
-    const result = await Effect.runPromise(program);
     return result.datum;
   }
   async awaitTx(txHash, checkInterval = 2e4) {
@@ -779,16 +862,19 @@ var Kupmios = class {
     const schema = S3.Array(UTxOSchema).annotations({
       identifier: "Array<KupmiosSchema.KupoUTxO>"
     });
-    const program = fetchKupoParse(pattern, schema).pipe(
-      Effect.repeat({
+    const result = await pipe3(
+      makeGet(pattern, schema, this.headers?.kupoHeader),
+      Effect2.provide(FetchHttpClient.layer),
+      Effect2.repeat({
         schedule: Schedule.exponential(checkInterval),
-        until: (result) => result.length > 0
+        until: (result2) => result2.length > 0
       }),
-      Effect.timeout(16e4),
-      Effect.catchAll((cause) => new KupmiosError({ cause })),
-      Effect.as(true)
+      Effect2.timeout(16e4),
+      Effect2.catchAll((cause) => new KupmiosError({ cause })),
+      Effect2.as(true),
+      Effect2.runPromise
     );
-    return await Effect.runPromise(program);
+    return result;
   }
   async submitTx(cbor) {
     const data = {
@@ -806,14 +892,18 @@ var Kupmios = class {
         })
       })
     );
-    const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      Effect.flatMap(
-        (response) => "error" in response ? Effect.fail(response) : Effect.succeed(response)
+    const { result } = await pipe3(
+      makePostAsJson(
+        this.ogmiosUrl,
+        data,
+        schema,
+        this.headers?.ogmiosHeader
       ),
-      Effect.timeout(1e4),
-      Effect.catchAll((cause) => new KupmiosError({ cause }))
+      Effect2.provide(FetchHttpClient.layer),
+      Effect2.timeout(1e4),
+      Effect2.catchAll((cause) => new KupmiosError({ cause })),
+      Effect2.runPromise
     );
-    const { result } = await Effect.runPromise(program);
     return result.transaction.id;
   }
   async evaluateTx(tx, additionalUTxOs) {
@@ -827,14 +917,18 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCSchema(S3.Array(RedeemerSchema));
-    const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      Effect.flatMap(
-        (response) => "error" in response ? Effect.fail(response) : Effect.succeed(response.result)
+    const { result } = await pipe3(
+      makePostAsJson(
+        this.ogmiosUrl,
+        data,
+        schema,
+        this.headers?.ogmiosHeader
       ),
-      Effect.timeout(1e4),
-      Effect.catchAll((cause) => new KupmiosError({ cause }))
+      Effect2.provide(FetchHttpClient.layer),
+      Effect2.timeout(1e4),
+      Effect2.catchAll((cause) => new KupmiosError({ cause })),
+      Effect2.runPromise
     );
-    const result = await Effect.runPromise(program);
     const evalRedeemers = result.map((item) => ({
       ex_units: {
         mem: item.budget.memory,
@@ -846,32 +940,33 @@ var Kupmios = class {
     return evalRedeemers;
   }
 };
-var getDatumEffect = (kupoUrl, datum_type, datum_hash) => Effect.gen(function* () {
+var getDatumEffect = (kupoUrl, datum_type, datum_hash, kupoHeader) => Effect2.gen(function* () {
   if (datum_type === "inline" && datum_hash) {
     const pattern = `${kupoUrl}/datums/${datum_hash}`;
     const schema = DatumSchema;
-    return yield* fetchKupoParse(pattern, schema).pipe(
-      Effect.flatMap(Effect.fromNullable),
-      Effect.map((result) => result.datum),
-      Effect.retry(
+    return yield* pipe3(
+      makeGet(pattern, schema, kupoHeader),
+      Effect2.flatMap(Effect2.fromNullable),
+      Effect2.map((result) => result.datum),
+      Effect2.retry(
         Schedule.compose(Schedule.exponential(50), Schedule.recurs(5))
       ),
-      Effect.timeout(5e3)
+      Effect2.timeout(5e3)
     );
   } else return void 0;
 });
-var getScriptEffect = (kupoUrl, script_hash) => Effect.gen(function* () {
+var getScriptEffect = (kupoUrl, script_hash, kupoHeader) => Effect2.gen(function* () {
   if (script_hash) {
     const pattern = `${kupoUrl}/scripts/${script_hash}`;
     const schema = ScriptSchema;
-    return yield* pipe2(
-      fetchKupoParse(pattern, schema),
-      Effect.flatMap(Effect.fromNullable),
-      Effect.retry(
+    return yield* pipe3(
+      makeGet(pattern, schema, kupoHeader),
+      Effect2.flatMap(Effect2.fromNullable),
+      Effect2.retry(
         Schedule.compose(Schedule.exponential(50), Schedule.recurs(5))
       ),
-      Effect.timeout(5e3),
-      Effect.map(({ language, script }) => {
+      Effect2.timeout(5e3),
+      Effect2.map(({ language, script }) => {
         switch (language) {
           case "native":
             return {
@@ -950,38 +1045,15 @@ var toProtocolParameters = (result) => {
     }
   };
 };
-var fetchOgmiosParse = (url, data, schema) => pipe2(
-  HttpClientRequest.post(url),
-  HttpClientRequest.jsonBody(data),
-  Effect.flatMap(HttpClient.fetch),
-  HttpClientResponse.json,
-  Effect.flatMap(S3.decodeUnknown(schema)),
-  Effect.catchTag(
-    "ParseError",
-    (e) => Effect.fail(ArrayFormatter.formatErrorSync(e))
-  )
-  // Effect.scoped
-);
-var fetchKupoParse = (url, schema) => pipe2(
-  HttpClientRequest.get(url),
-  HttpClient.fetchOk,
-  HttpClientResponse.json,
-  Effect.flatMap(S3.decodeUnknown(schema, { onExcessProperty: "error" })),
-  Effect.catchTag(
-    "ParseError",
-    (e) => Effect.fail(ArrayFormatter.formatErrorSync(e))
-  )
-  // Effect.scoped
-);
-var kupmiosUtxosToUtxos = (kupoURL, utxos) => Effect.forEach(
+var kupmiosUtxosToUtxos = (kupoURL, utxos, kupoHeader) => Effect2.forEach(
   utxos,
   (utxo) => {
-    return pipe2(
-      Effect.all([
-        getDatumEffect(kupoURL, utxo.datum_type, utxo.datum_hash),
-        getScriptEffect(kupoURL, utxo.script_hash)
+    return pipe3(
+      Effect2.all([
+        getDatumEffect(kupoURL, utxo.datum_type, utxo.datum_hash, kupoHeader),
+        getScriptEffect(kupoURL, utxo.script_hash, kupoHeader)
       ]),
-      Effect.map(
+      Effect2.map(
         ([datum, script]) => ({
           txHash: utxo.transaction_id,
           outputIndex: utxo.output_index,
@@ -1006,7 +1078,7 @@ import {
 import { coreToUtxo, getAddressDetails } from "@lucid-evolution/utils";
 import { fromHex as fromHex2 } from "@lucid-evolution/core-utils";
 import { walletFromSeed } from "@lucid-evolution/wallet";
-async function generateEmulatorAccountFrommPrivateKey(assets) {
+async function generateEmulatorAccountFromPrivateKey(assets) {
   const privateKey = CML.PrivateKey.generate_ed25519().to_bech32();
   const priv = CML.PrivateKey.from_bech32(privateKey);
   const pubKeyHash = priv.to_public().hash();
@@ -2079,18 +2151,12 @@ var toScriptRef = (reference_script) => {
 var lucid2 = package_default.version;
 
 // src/koios.ts
-import * as S5 from "@effect/schema/Schema";
 import { fromHex as fromHex4 } from "@lucid-evolution/core-utils";
 import { fromUnit as fromUnit3 } from "@lucid-evolution/utils";
 
 // src/internal/koios.ts
-import {
-  HttpClient as HttpClient2,
-  HttpClientRequest as HttpClientRequest2,
-  HttpClientResponse as HttpClientResponse2
-} from "@effect/platform";
-import * as S4 from "@effect/schema/Schema";
-import { Effect as Effect2, pipe as pipe3 } from "effect";
+import { FetchHttpClient as FetchHttpClient2 } from "@effect/platform";
+import { Effect as Effect3, pipe as pipe4, Schema as S4 } from "effect";
 import { applyDoubleCborEncoding as applyDoubleCborEncoding4 } from "@lucid-evolution/utils";
 var ProtocolParametersSchema2 = S4.Struct({
   pvt_motion_no_confidence: S4.Number,
@@ -2315,27 +2381,6 @@ var AccountInfoSchema = S4.Struct({
 var DatumInfo = S4.Struct({
   bytes: S4.String
 });
-var postWithSchemaValidation = (url, data, schema, headers = {}) => pipe3(
-  Effect2.succeed(HttpClientRequest2.post(url)),
-  Effect2.map(HttpClientRequest2.setHeaders(headers)),
-  Effect2.flatMap(
-    (req) => headers["Content-Type"] === "application/cbor" ? Effect2.succeed(
-      HttpClientRequest2.uint8ArrayBody(
-        data,
-        headers["Content-Type"]
-      )(req)
-    ) : HttpClientRequest2.jsonBody(data)(req)
-  ),
-  Effect2.flatMap(HttpClient2.fetch),
-  HttpClientResponse2.json,
-  Effect2.flatMap(S4.decodeUnknown(schema))
-);
-var getWithSchemaValidation = (url, schema) => pipe3(
-  HttpClientRequest2.get(url),
-  HttpClient2.fetchOk,
-  HttpClientResponse2.json,
-  Effect2.flatMap(S4.decodeUnknown(schema))
-);
 var toUTxO = (koiosUTxO, address) => ({
   txHash: koiosUTxO.tx_hash,
   outputIndex: koiosUTxO.tx_index,
@@ -2377,26 +2422,28 @@ var toScriptRef2 = (reference_script) => {
     }
   }
 };
-var getUtxosEffect = (baseUrl, addressOrCredential) => {
+var getUtxosEffect = (baseUrl, addressOrCredential, headers) => {
   const url = `${baseUrl}/address_info`;
   const body = {
     _addresses: [addressOrCredential]
   };
   const schema = AddressInfoSchema;
-  const result = pipe3(
-    Effect2.if(typeof addressOrCredential === "string", {
-      onFalse: () => Effect2.fail("Credential Type is not supported in Koios yet."),
-      onTrue: () => postWithSchemaValidation(url, body, schema)
+  const result = pipe4(
+    Effect3.if(typeof addressOrCredential === "string", {
+      onFalse: () => Effect3.fail("Credential Type is not supported in Koios yet."),
+      onTrue: () => makePostAsJson(url, body, schema, headers)
     }),
-    Effect2.map(
+    Effect3.map(
       ([result2]) => result2 ? result2.utxo_set.map((koiosUtxo) => toUTxO(koiosUtxo, result2.address)) : []
-    )
+    ),
+    Effect3.provide(FetchHttpClient2.layer)
   );
   return result;
 };
 
 // src/koios.ts
-import { Data as Data2, Effect as Effect3, pipe as pipe4, Schedule as Schedule2 } from "effect";
+import { Data as Data2, Effect as Effect4, pipe as pipe5, Schedule as Schedule2, Schema as S5 } from "effect";
+import { FetchHttpClient as FetchHttpClient3 } from "@effect/platform";
 var KoiosError = class extends Data2.TaggedError("KoiosError") {
   get message() {
     return `${this.cause}`;
@@ -2404,17 +2451,22 @@ var KoiosError = class extends Data2.TaggedError("KoiosError") {
 };
 var Koios = class {
   baseUrl;
-  constructor(baseUrl) {
+  token;
+  constructor(baseUrl, token) {
     this.baseUrl = baseUrl;
+    this.token = token;
   }
   async getProtocolParameters() {
     const url = `${this.baseUrl}/epoch_params?limit=1`;
     const schema = S5.Array(ProtocolParametersSchema2);
-    const [result] = await pipe4(
-      getWithSchemaValidation(url, schema),
-      Effect3.timeout(1e4),
-      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
-      Effect3.runPromise
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const [result] = await pipe5(
+      makeGet(url, schema, bearerToken),
+      // Allows for dependency injection and easier testing
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return {
       minFeeA: result.min_fee_a,
@@ -2456,55 +2508,64 @@ var Koios = class {
     };
   }
   async getUtxos(addressOrCredential) {
-    const result = await pipe4(
-      getUtxosEffect(this.baseUrl, addressOrCredential),
-      Effect3.timeout(1e4),
-      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
-      Effect3.runPromise
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await pipe5(
+      getUtxosEffect(this.baseUrl, addressOrCredential, bearerToken),
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return result;
   }
   async getUtxosWithUnit(addressOrCredential, unit) {
-    const result = await pipe4(
-      getUtxosEffect(this.baseUrl, addressOrCredential),
-      Effect3.map(
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await pipe5(
+      getUtxosEffect(this.baseUrl, addressOrCredential, bearerToken),
+      Effect4.map(
         (utxos) => utxos.filter((utxo) => {
           const keys = Object.keys(utxo.assets);
           return keys.length > 0 && keys.includes(unit);
         })
       ),
-      Effect3.timeout(1e4),
-      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
-      Effect3.runPromise
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return result;
   }
   async getUtxoByUnit(unit) {
     let { policyId, assetName } = fromUnit3(unit);
     const url = `${this.baseUrl}/asset_addresses?_asset_policy=${policyId}&_asset_name=${assetName}`;
-    const result = await pipe4(
-      getWithSchemaValidation(url, S5.Array(AssetAddressSchema)),
-      Effect3.flatMap(
-        (adresses) => adresses.length === 0 ? Effect3.fail("Unit not found") : Effect3.succeed(adresses)
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await pipe5(
+      makeGet(url, S5.Array(AssetAddressSchema), bearerToken),
+      // Allows for dependency injection and easier testing
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.flatMap(
+        (adresses) => adresses.length === 0 ? Effect4.fail("Unit not found") : Effect4.succeed(adresses)
       ),
-      Effect3.flatMap(
-        (adresses) => adresses.length > 1 ? Effect3.fail("Unit needs to be an NFT or only held by one address.") : Effect3.succeed(adresses[0])
+      Effect4.flatMap(
+        (adresses) => adresses.length > 1 ? Effect4.fail("Unit needs to be an NFT or only held by one address.") : Effect4.succeed(adresses[0])
       ),
-      Effect3.flatMap(
-        (address) => getUtxosEffect(this.baseUrl, address.payment_address)
+      Effect4.flatMap(
+        (address) => getUtxosEffect(
+          this.baseUrl,
+          address.payment_address,
+          bearerToken
+        )
       ),
-      Effect3.map(
+      Effect4.map(
         (utxos) => utxos.filter((utxo) => {
           const keys = Object.keys(utxo.assets);
           return keys.length > 0 && keys.includes(unit);
         })
       ),
-      Effect3.flatMap(
-        (utxos) => utxos.length > 1 ? Effect3.fail("Unit needs to be an NFT or only held by one address.") : Effect3.succeed(utxos[0])
+      Effect4.flatMap(
+        (utxos) => utxos.length > 1 ? Effect4.fail("Unit needs to be an NFT or only held by one address.") : Effect4.succeed(utxos[0])
       ),
-      Effect3.timeout(1e4),
-      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
-      Effect3.runPromise
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return result;
   }
@@ -2516,11 +2577,14 @@ var Koios = class {
       _scripts: true
     };
     const schema = S5.Array(TxInfoSchema);
-    const [result] = await pipe4(
-      postWithSchemaValidation(url, body, schema),
-      Effect3.timeout(1e4),
-      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
-      Effect3.runPromise
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const [result] = await pipe5(
+      makePostAsJson(url, body, schema, bearerToken),
+      // Allows for dependency injection and easier testing
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     if (result) {
       const utxos = result.outputs.map(
@@ -2553,18 +2617,22 @@ var Koios = class {
       _stake_addresses: [rewardAddress]
     };
     const url = `${this.baseUrl}/account_info`;
-    const result = await pipe4(
-      postWithSchemaValidation(
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await pipe5(
+      makePostAsJson(
         url,
         body,
-        S5.Array(AccountInfoSchema)
+        S5.Array(AccountInfoSchema),
+        bearerToken
       ),
-      Effect3.flatMap(
-        (result2) => result2.length === 0 ? Effect3.fail("No Delegation Found by Reward Address") : Effect3.succeed(result2[0])
+      // Allows for dependency injection and easier testing
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.flatMap(
+        (result2) => result2.length === 0 ? Effect4.fail("No Delegation Found by Reward Address") : Effect4.succeed(result2[0])
       ),
-      Effect3.timeout(1e4),
-      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
-      Effect3.runPromise
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return {
       poolId: result.delegated_pool || null,
@@ -2576,14 +2644,22 @@ var Koios = class {
     const body = {
       _datum_hashes: [datumHash]
     };
-    const result = await pipe4(
-      postWithSchemaValidation(url, body, S5.Array(DatumInfo)),
-      Effect3.flatMap(
-        (result2) => result2.length === 0 ? Effect3.fail("No Datum Found by Datum Hash") : Effect3.succeed(result2[0])
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await pipe5(
+      makePostAsJson(
+        url,
+        body,
+        S5.Array(DatumInfo),
+        bearerToken
       ),
-      Effect3.timeout(1e4),
-      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
-      Effect3.runPromise
+      // Allows for dependency injection and easier testing
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.flatMap(
+        (result2) => result2.length === 0 ? Effect4.fail("No Datum Found by Datum Hash") : Effect4.succeed(result2[0])
+      ),
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return result.bytes;
   }
@@ -2593,16 +2669,19 @@ var Koios = class {
       _tx_hashes: [txHash]
     };
     const schema = S5.Array(TxInfoSchema);
-    const result = await pipe4(
-      postWithSchemaValidation(url, body, schema),
-      Effect3.repeat({
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await pipe5(
+      makePostAsJson(url, body, schema, bearerToken),
+      Effect4.repeat({
         schedule: Schedule2.exponential(checkInterval),
         until: (result2) => result2.length > 0
       }),
-      Effect3.timeout(16e4),
-      Effect3.orDie,
-      Effect3.as(true),
-      Effect3.runPromise
+      // Allows for dependency injection and easier testing
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.timeout(16e4),
+      Effect4.orDie,
+      Effect4.as(true),
+      Effect4.runPromise
     );
     return result;
   }
@@ -2610,13 +2689,14 @@ var Koios = class {
     const url = `${this.baseUrl}/submittx`;
     const body = fromHex4(tx);
     const schema = TxHashSchema;
-    const result = await pipe4(
-      postWithSchemaValidation(url, body, schema, {
-        "Content-Type": "application/cbor"
-      }),
-      Effect3.timeout(1e4),
-      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
-      Effect3.runPromise
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await pipe5(
+      makePostAsUint8Array(url, body, schema, bearerToken),
+      // Allows for dependency injection and easier testing
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return result;
   }
@@ -2632,14 +2712,14 @@ var Koios = class {
       id: null
     };
     const schema = JSONRPCSchema(S5.Array(RedeemerSchema));
-    const result = await pipe4(
-      postWithSchemaValidation(url, body, schema),
-      Effect3.flatMap(
-        (response) => "error" in response ? Effect3.fail(response) : Effect3.succeed(response.result)
-      ),
-      Effect3.timeout(1e4),
-      Effect3.catchAllCause((cause) => new KoiosError({ cause })),
-      Effect3.runPromise
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const { result } = await pipe5(
+      makePostAsJson(url, body, schema, bearerToken),
+      // Allows for dependency injection and easier testing
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     const evalRedeemers = result.map((item) => ({
       ex_units: {
@@ -2661,5 +2741,5 @@ export {
   KupmiosError,
   Maestro,
   generateEmulatorAccount,
-  generateEmulatorAccountFrommPrivateKey
+  generateEmulatorAccountFromPrivateKey
 };