@lucid-evolution/provider 0.1.81 → 0.1.83

package/dist/index.cjs

@@ -52,7 +52,7 @@ var import_utils2 = require("@lucid-evolution/utils");
 // package.json
 var package_default = {
   name: "@lucid-evolution/provider",
-  version: "0.1.81",
+  version: "0.1.83",
   description: "",
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
@@ -84,13 +84,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",
@@ -452,59 +452,55 @@ var lucid = package_default.version;
 
 // src/kupmios.ts
 var import_utils4 = require("@lucid-evolution/utils");
-var S3 = __toESM(require("@effect/schema/Schema"), 1);
-var import_effect2 = require("effect");
-var import_platform = require("@effect/platform");
-var import_schema = require("@effect/schema");
+var import_effect5 = require("effect");
+var import_effect6 = require("effect");
 
 // src/internal/ogmios.ts
-var S = __toESM(require("@effect/schema/Schema"), 1);
+var import_effect2 = require("effect");
 var import_utils3 = require("@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 LovelaceAsset = S.Struct({
-  lovelace: S.Number
+var JSONRPCSchema = (schema) => import_effect2.Schema.Struct({
+  jsonrpc: import_effect2.Schema.String,
+  method: import_effect2.Schema.optional(import_effect2.Schema.String),
+  id: import_effect2.Schema.NullOr(import_effect2.Schema.Number),
+  result: schema
+}).annotations({ identifier: "JSONRPCSchema" });
+var LovelaceAsset = import_effect2.Schema.Struct({
+  lovelace: import_effect2.Schema.Number
 });
-var TupleNumberFromString = S.compose(
-  S.split("/"),
-  S.Array(S.NumberFromString)
+var TupleNumberFromString = import_effect2.Schema.compose(
+  import_effect2.Schema.split("/"),
+  import_effect2.Schema.Array(import_effect2.Schema.NumberFromString)
 );
-var ProtocolParametersSchema = S.Struct({
-  minFeeCoefficient: S.Number,
-  minFeeReferenceScripts: S.Struct({
-    base: S.Number,
-    range: S.Number,
-    multiplier: S.Number
+var ProtocolParametersSchema = import_effect2.Schema.Struct({
+  minFeeCoefficient: import_effect2.Schema.Number,
+  minFeeReferenceScripts: import_effect2.Schema.Struct({
+    base: import_effect2.Schema.Number,
+    range: import_effect2.Schema.Number,
+    multiplier: import_effect2.Schema.Number
   }),
-  maxReferenceScriptsSize: S.Struct({
-    bytes: S.Number
+  maxReferenceScriptsSize: import_effect2.Schema.Struct({
+    bytes: import_effect2.Schema.Number
   }),
-  stakePoolVotingThresholds: S.Struct({
+  stakePoolVotingThresholds: import_effect2.Schema.Struct({
     noConfidence: TupleNumberFromString,
-    constitutionalCommittee: S.Struct({
+    constitutionalCommittee: import_effect2.Schema.Struct({
       default: TupleNumberFromString,
       stateOfNoConfidence: TupleNumberFromString
     }),
     hardForkInitiation: TupleNumberFromString,
-    protocolParametersUpdate: S.Struct({
+    protocolParametersUpdate: import_effect2.Schema.Struct({
       security: TupleNumberFromString
     })
   }),
-  delegateRepresentativeVotingThresholds: S.Struct({
+  delegateRepresentativeVotingThresholds: import_effect2.Schema.Struct({
     noConfidence: TupleNumberFromString,
-    constitutionalCommittee: S.Struct({
+    constitutionalCommittee: import_effect2.Schema.Struct({
       default: TupleNumberFromString,
       stateOfNoConfidence: TupleNumberFromString
     }),
     constitution: TupleNumberFromString,
     hardForkInitiation: TupleNumberFromString,
-    protocolParametersUpdate: S.Struct({
+    protocolParametersUpdate: import_effect2.Schema.Struct({
       network: TupleNumberFromString,
       economic: TupleNumberFromString,
       technical: TupleNumberFromString,
@@ -512,62 +508,62 @@ var ProtocolParametersSchema = S.Struct({
     }),
     treasuryWithdrawals: TupleNumberFromString
   }),
-  constitutionalCommitteeMinSize: S.optional(S.Number),
-  constitutionalCommitteeMaxTermLength: S.Number,
-  governanceActionLifetime: S.Number,
-  governanceActionDeposit: S.Struct({
+  constitutionalCommitteeMinSize: import_effect2.Schema.optional(import_effect2.Schema.Number),
+  constitutionalCommitteeMaxTermLength: import_effect2.Schema.Number,
+  governanceActionLifetime: import_effect2.Schema.Number,
+  governanceActionDeposit: import_effect2.Schema.Struct({
     ada: LovelaceAsset
   }),
-  delegateRepresentativeDeposit: S.Struct({
+  delegateRepresentativeDeposit: import_effect2.Schema.Struct({
     ada: LovelaceAsset
   }),
-  delegateRepresentativeMaxIdleTime: 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,
+  delegateRepresentativeMaxIdleTime: import_effect2.Schema.Number,
+  minFeeConstant: import_effect2.Schema.Struct({ ada: LovelaceAsset }),
+  maxBlockBodySize: import_effect2.Schema.Struct({ bytes: import_effect2.Schema.Number }),
+  maxBlockHeaderSize: import_effect2.Schema.Struct({ bytes: import_effect2.Schema.Number }),
+  maxTransactionSize: import_effect2.Schema.Struct({ bytes: import_effect2.Schema.Number }),
+  stakeCredentialDeposit: import_effect2.Schema.Struct({ ada: LovelaceAsset }),
+  stakePoolDeposit: import_effect2.Schema.Struct({ ada: LovelaceAsset }),
+  stakePoolRetirementEpochBound: import_effect2.Schema.Number,
+  desiredNumberOfStakePools: import_effect2.Schema.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),
-    "plutus:v3": S.Array(S.Number)
+  minStakePoolCost: import_effect2.Schema.Struct({ ada: LovelaceAsset }),
+  minUtxoDepositConstant: import_effect2.Schema.Struct({ ada: LovelaceAsset }),
+  minUtxoDepositCoefficient: import_effect2.Schema.Number,
+  plutusCostModels: import_effect2.Schema.Struct({
+    "plutus:v1": import_effect2.Schema.Array(import_effect2.Schema.Number),
+    "plutus:v2": import_effect2.Schema.Array(import_effect2.Schema.Number),
+    "plutus:v3": import_effect2.Schema.Array(import_effect2.Schema.Number)
   }),
-  scriptExecutionPrices: S.Struct({
+  scriptExecutionPrices: import_effect2.Schema.Struct({
     memory: TupleNumberFromString,
     cpu: TupleNumberFromString
   }),
-  maxExecutionUnitsPerTransaction: S.Struct({
-    memory: S.Number,
-    cpu: S.Number
+  maxExecutionUnitsPerTransaction: import_effect2.Schema.Struct({
+    memory: import_effect2.Schema.Number,
+    cpu: import_effect2.Schema.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 Delegation = S.NullOr(
-  S.Record(
-    S.String,
-    S.Struct({
-      delegate: S.Struct({ id: S.String }),
-      rewards: S.Struct({ ada: S.Struct({ lovelace: S.Number }) }),
-      deposit: S.Struct({ ada: S.Struct({ lovelace: S.Number }) })
+  maxExecutionUnitsPerBlock: import_effect2.Schema.Struct({ memory: import_effect2.Schema.Number, cpu: import_effect2.Schema.Number }),
+  maxValueSize: import_effect2.Schema.Struct({ bytes: import_effect2.Schema.Number }),
+  collateralPercentage: import_effect2.Schema.Number,
+  maxCollateralInputs: import_effect2.Schema.Number,
+  version: import_effect2.Schema.Struct({ major: import_effect2.Schema.Number, minor: import_effect2.Schema.Number })
+}).annotations({ identifier: "ProtocolParametersSchema" });
+var Delegation = import_effect2.Schema.NullOr(
+  import_effect2.Schema.Record({
+    key: import_effect2.Schema.String,
+    value: import_effect2.Schema.Struct({
+      delegate: import_effect2.Schema.Struct({ id: import_effect2.Schema.String }),
+      rewards: import_effect2.Schema.Struct({ ada: import_effect2.Schema.Struct({ lovelace: import_effect2.Schema.Number }) }),
+      deposit: import_effect2.Schema.Struct({ ada: import_effect2.Schema.Struct({ lovelace: import_effect2.Schema.Number }) })
     })
-  )
+  })
 );
-var RedeemerSchema = S.Struct({
-  validator: S.Struct({
-    purpose: S.Literal(
+var RedeemerSchema = import_effect2.Schema.Struct({
+  validator: import_effect2.Schema.Struct({
+    purpose: import_effect2.Schema.Literal(
       "spend",
       "mint",
       "publish",
@@ -575,13 +571,13 @@ var RedeemerSchema = S.Struct({
       "vote",
       "propose"
     ),
-    index: S.Int
+    index: import_effect2.Schema.Int
   }),
-  budget: S.Struct({
-    memory: S.Int,
-    cpu: S.Int
+  budget: import_effect2.Schema.Struct({
+    memory: import_effect2.Schema.Int,
+    cpu: import_effect2.Schema.Int
   })
-});
+}).annotations({ identifier: "RedeemerSchema" });
 var toOgmiosUTxOs = (utxos) => {
   const toOgmiosScript = (scriptRef) => {
     if (scriptRef) {
@@ -637,65 +633,132 @@ var toOgmiosUTxOs = (utxos) => {
 };
 
 // src/internal/kupo.ts
-var S2 = __toESM(require("@effect/schema/Schema"), 1);
-var ValueSchema = S2.Struct({
-  coins: S2.Number,
-  assets: S2.Record(S2.String, S2.Number)
+var import_effect3 = require("effect");
+var ValueSchema = import_effect3.Schema.Struct({
+  coins: import_effect3.Schema.Number,
+  assets: import_effect3.Schema.Record({ key: import_effect3.Schema.String, value: import_effect3.Schema.Number })
 });
-var UTxOSchema = S2.Struct({
-  transaction_index: S2.Number,
-  transaction_id: S2.String,
-  output_index: S2.Number,
-  address: S2.String,
+var UTxOSchema = import_effect3.Schema.Struct({
+  transaction_index: import_effect3.Schema.Number,
+  transaction_id: import_effect3.Schema.String,
+  output_index: import_effect3.Schema.Number,
+  address: import_effect3.Schema.String,
   value: ValueSchema,
-  datum_hash: S2.NullOr(S2.String),
-  datum_type: S2.optional(S2.Literal("hash", "inline")),
-  script_hash: S2.NullOr(S2.String),
-  created_at: S2.Struct({
-    slot_no: S2.Number,
-    header_hash: S2.String
+  datum_hash: import_effect3.Schema.NullOr(import_effect3.Schema.String),
+  datum_type: import_effect3.Schema.optional(import_effect3.Schema.Literal("hash", "inline")),
+  script_hash: import_effect3.Schema.NullOr(import_effect3.Schema.String),
+  created_at: import_effect3.Schema.Struct({
+    slot_no: import_effect3.Schema.Number,
+    header_hash: import_effect3.Schema.String
   }),
-  spent_at: S2.NullOr(
-    S2.Struct({
-      slot_no: S2.Number,
-      header_hash: S2.String
+  spent_at: import_effect3.Schema.NullOr(
+    import_effect3.Schema.Struct({
+      slot_no: import_effect3.Schema.Number,
+      header_hash: import_effect3.Schema.String
     })
   )
 });
-var ScriptSchema = S2.NullOr(
-  S2.Struct({
-    language: S2.Literal("native", "plutus:v1", "plutus:v2", "plutus:v3"),
-    script: S2.String
+var ScriptSchema = import_effect3.Schema.NullOr(
+  import_effect3.Schema.Struct({
+    language: import_effect3.Schema.Literal("native", "plutus:v1", "plutus:v2", "plutus:v3"),
+    script: import_effect3.Schema.String
   })
 );
-var DatumSchema = S2.NullOr(S2.Struct({ datum: S2.String }));
-var DelegationSchema = S2.NullOr(
-  S2.Record(
-    S2.String,
-    S2.Struct({
-      delegate: S2.Struct({ id: S2.String }),
-      rewards: S2.Struct({ ada: S2.Struct({ lovelace: S2.Number }) }),
-      deposit: S2.Struct({ ada: S2.Struct({ lovelace: S2.Number }) })
+var DatumSchema = import_effect3.Schema.NullOr(import_effect3.Schema.Struct({ datum: import_effect3.Schema.String }));
+var DelegationSchema = import_effect3.Schema.NullOr(
+  import_effect3.Schema.Record({
+    key: import_effect3.Schema.String,
+    value: import_effect3.Schema.Struct({
+      delegate: import_effect3.Schema.Struct({ id: import_effect3.Schema.String }),
+      rewards: import_effect3.Schema.Struct({ ada: import_effect3.Schema.Struct({ lovelace: import_effect3.Schema.Number }) }),
+      deposit: import_effect3.Schema.Struct({ ada: import_effect3.Schema.Struct({ lovelace: import_effect3.Schema.Number }) })
     })
+  })
+);
+
+// src/internal/HttpUtils.ts
+var import_platform = require("@effect/platform");
+var import_effect4 = require("effect");
+var filterStatusOk = (self) => self.status >= 200 && self.status < 300 ? import_effect4.Effect.succeed(self) : self.text.pipe(
+  import_effect4.Effect.flatMap(
+    (text) => import_effect4.Effect.fail(
+      new import_platform.HttpClientError.ResponseError({
+        response: self,
+        request: self.request,
+        reason: "StatusCode",
+        description: `non 2xx status code : ${text}`
+      })
+    )
   )
 );
+var makeGet = (url, schema, headers) => (0, import_effect4.pipe)(
+  // Initiate a GET request to the specified URL
+  import_platform.HttpClientRequest.get(url),
+  // Conditional bearer token authentication
+  headers ? import_platform.HttpClientRequest.setHeaders(headers) : import_effect4.identity,
+  // Execute the HTTP request and retrieve the response
+  import_platform.HttpClient.execute,
+  // Ensure only 2xx responses are treated as successes.
+  import_effect4.Effect.flatMap(filterStatusOk),
+  // Parse the response body using the provided JSON schema
+  // This validates and transforms the response to the expected type
+  import_effect4.Effect.flatMap(import_platform.HttpClientResponse.schemaBodyJson(schema)),
+  // Ensure request is aborted if the program is interrupted
+  // Prevents resource leaks and ensures clean request termination
+  import_effect4.Effect.scoped
+);
+var makePostAsJson = (url, data, schema, headers) => (0, import_effect4.pipe)(
+  // Initiate a POST request to the specified URL
+  import_platform.HttpClientRequest.post(url),
+  // Conditional headers
+  headers ? import_platform.HttpClientRequest.setHeaders(headers) : import_effect4.identity,
+  // Set the request body as Json
+  import_platform.HttpClientRequest.bodyJson(data),
+  // Execute the HTTP request and retrieve the response
+  import_effect4.Effect.flatMap(import_platform.HttpClient.execute),
+  // Ensure only 2xx responses are treated as successes.
+  import_effect4.Effect.flatMap(filterStatusOk),
+  // Parse the response body using the provided JSON schema
+  // This validates and transforms the response to the expected type
+  import_effect4.Effect.flatMap(import_platform.HttpClientResponse.schemaBodyJson(schema)),
+  // Ensure request is aborted if the program is interrupted
+  // Prevents resource leaks and ensures clean request termination
+  import_effect4.Effect.scoped
+);
+var makePostAsUint8Array = (url, data, schema, headers) => (0, import_effect4.pipe)(
+  // Initiate a POST request to the specified URL
+  import_platform.HttpClientRequest.post(url),
+  // Conditional bearer token authentication
+  headers ? import_platform.HttpClientRequest.setHeaders(headers) : import_effect4.identity,
+  // Set the request body as a Uint8Array with CBOR content type
+  import_platform.HttpClientRequest.bodyUint8Array(data, "application/cbor"),
+  // Execute the HTTP request and retrieve the response
+  import_platform.HttpClient.execute,
+  // Ensure only 2xx responses are treated as successes.
+  import_effect4.Effect.flatMap(filterStatusOk),
+  // Parse the response body using the provided JSON schema
+  // This validates and transforms the response to the expected type
+  import_effect4.Effect.flatMap(import_platform.HttpClientResponse.schemaBodyJson(schema)),
+  // Ensure request is aborted if the program is interrupted
+  // Prevents resource leaks and ensures clean request termination
+  import_effect4.Effect.scoped
+);
 
 // src/kupmios.ts
-var KupmiosError = class extends import_effect2.Data.TaggedError("KupmiosError") {
+var import_platform2 = require("@effect/platform");
+var KupmiosError = class extends import_effect6.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 = {
@@ -705,27 +768,33 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCSchema(ProtocolParametersSchema);
-    const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      import_effect2.Effect.flatMap(
-        (response) => "error" in response ? import_effect2.Effect.fail(response) : import_effect2.Effect.succeed(response.result)
+    const { result } = await (0, import_effect6.pipe)(
+      makePostAsJson(
+        this.ogmiosUrl,
+        data,
+        schema,
+        this.headers?.ogmiosHeader
       ),
-      import_effect2.Effect.timeout(1e4),
-      import_effect2.Effect.catchAll((cause) => new KupmiosError({ cause }))
+      import_effect6.Effect.timeout(1e4),
+      import_effect6.Effect.catchAll((cause) => new KupmiosError({ cause })),
+      import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+      import_effect6.Effect.runPromise
     );
-    const result = await import_effect2.Effect.runPromise(program);
     return toProtocolParameters(result);
   }
   async getUtxos(addressOrCredential) {
     const isAddress = typeof addressOrCredential === "string";
     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(
-      import_effect2.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-      import_effect2.Effect.timeout(1e4),
-      import_effect2.Effect.catchAll((cause) => new KupmiosError({ cause }))
+    const schema = import_effect5.Schema.Array(UTxOSchema);
+    const utxos = await (0, import_effect6.pipe)(
+      makeGet(pattern, schema, this.headers?.kupoHeader),
+      import_effect6.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      import_effect6.Effect.timeout(1e4),
+      import_effect6.Effect.catchAll((cause) => new KupmiosError({ cause })),
+      import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+      import_effect6.Effect.runPromise
     );
-    const utxos = await import_effect2.Effect.runPromise(program);
     return utxos;
   }
   async getUtxosWithUnit(addressOrCredential, unit) {
@@ -733,25 +802,29 @@ var Kupmios = class {
     const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
     const { policyId, assetName } = (0, import_utils4.fromUnit)(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(
-      import_effect2.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-      import_effect2.Effect.timeout(1e4),
-      import_effect2.Effect.catchAll((cause) => new KupmiosError({ cause }))
+    const schema = import_effect5.Schema.Array(UTxOSchema);
+    const utxos = await (0, import_effect6.pipe)(
+      makeGet(pattern, schema, this.headers?.kupoHeader),
+      import_effect6.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      import_effect6.Effect.timeout(1e4),
+      import_effect6.Effect.catchAll((cause) => new KupmiosError({ cause })),
+      import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+      import_effect6.Effect.runPromise
     );
-    const utxos = await import_effect2.Effect.runPromise(program);
     return utxos;
   }
   async getUtxoByUnit(unit) {
     const { policyId, assetName } = (0, import_utils4.fromUnit)(unit);
     const pattern = `${this.kupoUrl}/matches/${policyId}.${assetName ? `${assetName}` : "*"}?unspent`;
-    const schema = S3.Array(UTxOSchema);
-    const program = fetchKupoParse(pattern, schema).pipe(
-      import_effect2.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-      import_effect2.Effect.timeout(1e4),
-      import_effect2.Effect.catchAll((cause) => new KupmiosError({ cause }))
+    const schema = import_effect5.Schema.Array(UTxOSchema);
+    const utxos = await (0, import_effect6.pipe)(
+      makeGet(pattern, schema, this.headers?.kupoHeader),
+      import_effect6.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+      import_effect6.Effect.timeout(1e4),
+      import_effect6.Effect.catchAll((cause) => new KupmiosError({ cause })),
+      import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+      import_effect6.Effect.runPromise
     );
-    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.");
     }
@@ -762,17 +835,20 @@ var Kupmios = class {
       ...new Set(outRefs.map((outRef) => outRef.txHash))
     ];
     const mkPattern = (txHash) => `${this.kupoUrl}/matches/*@${txHash}?unspent`;
-    const schema = S3.Array(UTxOSchema);
-    const program = import_effect2.Effect.forEach(
+    const schema = import_effect5.Schema.Array(UTxOSchema);
+    const program = import_effect6.Effect.forEach(
       queryHashes,
-      (txHash) => fetchKupoParse(mkPattern(txHash), schema).pipe(
-        import_effect2.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
-        import_effect2.Effect.timeout(1e4),
-        import_effect2.Effect.catchAll((cause) => new KupmiosError({ cause }))
+      (txHash) => (0, import_effect6.pipe)(
+        makeGet(mkPattern(txHash), schema, this.headers?.kupoHeader),
+        import_effect6.Effect.flatMap((u) => kupmiosUtxosToUtxos(this.kupoUrl, u)),
+        import_effect6.Effect.timeout(1e4),
+        import_effect6.Effect.catchAll((cause) => new KupmiosError({ cause }))
       )
     );
-    const utxos = await import_effect2.Effect.runPromise(program);
-    return import_effect2.Array.flatten(utxos).filter(
+    const utxos = await import_effect6.Effect.runPromise(
+      (0, import_effect6.pipe)(program, import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer))
+    );
+    return import_effect6.Array.flatten(utxos).filter(
       (utxo) => outRefs.some(
         (outRef) => utxo.txHash === outRef.txHash && utxo.outputIndex === outRef.outputIndex
       )
@@ -786,14 +862,18 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCSchema(Delegation);
-    const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      import_effect2.Effect.flatMap(
-        (response) => "error" in response ? import_effect2.Effect.fail(response) : import_effect2.Effect.succeed(response.result)
+    const { result } = await (0, import_effect6.pipe)(
+      makePostAsJson(
+        this.ogmiosUrl,
+        data,
+        schema,
+        this.headers?.ogmiosHeader
       ),
-      import_effect2.Effect.timeout(1e4),
-      import_effect2.Effect.catchAll((cause) => new KupmiosError({ cause }))
+      import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+      import_effect6.Effect.timeout(1e4),
+      import_effect6.Effect.catchAll((cause) => new KupmiosError({ cause })),
+      import_effect6.Effect.runPromise
     );
-    const result = await import_effect2.Effect.runPromise(program);
     const delegation = result ? Object.values(result)[0] : null;
     return {
       poolId: delegation?.delegate?.id || null,
@@ -803,29 +883,34 @@ var Kupmios = class {
   async getDatum(datumHash) {
     const pattern = `${this.kupoUrl}/datums/${datumHash}`;
     const schema = DatumSchema;
-    const program = fetchKupoParse(pattern, schema).pipe(
-      import_effect2.Effect.timeout(1e4),
-      import_effect2.Effect.flatMap(import_effect2.Effect.fromNullable),
-      import_effect2.Effect.catchAll((cause) => new KupmiosError({ cause }))
+    const result = await (0, import_effect6.pipe)(
+      makeGet(pattern, schema, this.headers?.kupoHeader),
+      import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+      import_effect6.Effect.timeout(1e4),
+      import_effect6.Effect.flatMap(import_effect6.Effect.fromNullable),
+      import_effect6.Effect.catchAll((cause) => new KupmiosError({ cause })),
+      import_effect6.Effect.runPromise
     );
-    const result = await import_effect2.Effect.runPromise(program);
     return result.datum;
   }
   async awaitTx(txHash, checkInterval = 2e4) {
     const pattern = `${this.kupoUrl}/matches/*@${txHash}`;
-    const schema = S3.Array(UTxOSchema).annotations({
+    const schema = import_effect5.Schema.Array(UTxOSchema).annotations({
       identifier: "Array<KupmiosSchema.KupoUTxO>"
     });
-    const program = fetchKupoParse(pattern, schema).pipe(
-      import_effect2.Effect.repeat({
-        schedule: import_effect2.Schedule.exponential(checkInterval),
-        until: (result) => result.length > 0
+    const result = await (0, import_effect6.pipe)(
+      makeGet(pattern, schema, this.headers?.kupoHeader),
+      import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+      import_effect6.Effect.repeat({
+        schedule: import_effect6.Schedule.exponential(checkInterval),
+        until: (result2) => result2.length > 0
       }),
-      import_effect2.Effect.timeout(16e4),
-      import_effect2.Effect.catchAll((cause) => new KupmiosError({ cause })),
-      import_effect2.Effect.as(true)
+      import_effect6.Effect.timeout(16e4),
+      import_effect6.Effect.catchAll((cause) => new KupmiosError({ cause })),
+      import_effect6.Effect.as(true),
+      import_effect6.Effect.runPromise
     );
-    return await import_effect2.Effect.runPromise(program);
+    return result;
   }
   async submitTx(cbor) {
     const data = {
@@ -837,20 +922,24 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCSchema(
-      S3.Struct({
-        transaction: S3.Struct({
-          id: S3.String
+      import_effect5.Schema.Struct({
+        transaction: import_effect5.Schema.Struct({
+          id: import_effect5.Schema.String
         })
       })
     );
-    const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      import_effect2.Effect.flatMap(
-        (response) => "error" in response ? import_effect2.Effect.fail(response) : import_effect2.Effect.succeed(response)
+    const { result } = await (0, import_effect6.pipe)(
+      makePostAsJson(
+        this.ogmiosUrl,
+        data,
+        schema,
+        this.headers?.ogmiosHeader
       ),
-      import_effect2.Effect.timeout(1e4),
-      import_effect2.Effect.catchAll((cause) => new KupmiosError({ cause }))
+      import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+      import_effect6.Effect.timeout(1e4),
+      import_effect6.Effect.catchAll((cause) => new KupmiosError({ cause })),
+      import_effect6.Effect.runPromise
     );
-    const { result } = await import_effect2.Effect.runPromise(program);
     return result.transaction.id;
   }
   async evaluateTx(tx, additionalUTxOs) {
@@ -863,15 +952,19 @@ var Kupmios = class {
       },
       id: null
     };
-    const schema = JSONRPCSchema(S3.Array(RedeemerSchema));
-    const program = fetchOgmiosParse(this.ogmiosUrl, data, schema).pipe(
-      import_effect2.Effect.flatMap(
-        (response) => "error" in response ? import_effect2.Effect.fail(response) : import_effect2.Effect.succeed(response.result)
+    const schema = JSONRPCSchema(import_effect5.Schema.Array(RedeemerSchema));
+    const { result } = await (0, import_effect6.pipe)(
+      makePostAsJson(
+        this.ogmiosUrl,
+        data,
+        schema,
+        this.headers?.ogmiosHeader
       ),
-      import_effect2.Effect.timeout(1e4),
-      import_effect2.Effect.catchAll((cause) => new KupmiosError({ cause }))
+      import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+      import_effect6.Effect.timeout(1e4),
+      import_effect6.Effect.catchAll((cause) => new KupmiosError({ cause })),
+      import_effect6.Effect.runPromise
     );
-    const result = await import_effect2.Effect.runPromise(program);
     const evalRedeemers = result.map((item) => ({
       ex_units: {
         mem: item.budget.memory,
@@ -883,32 +976,33 @@ var Kupmios = class {
     return evalRedeemers;
   }
 };
-var getDatumEffect = (kupoUrl, datum_type, datum_hash) => import_effect2.Effect.gen(function* () {
+var getDatumEffect = (kupoUrl, datum_type, datum_hash, kupoHeader) => import_effect6.Effect.gen(function* () {
   if (datum_type === "inline" && datum_hash) {
     const pattern = `${kupoUrl}/datums/${datum_hash}`;
     const schema = DatumSchema;
-    return yield* fetchKupoParse(pattern, schema).pipe(
-      import_effect2.Effect.flatMap(import_effect2.Effect.fromNullable),
-      import_effect2.Effect.map((result) => result.datum),
-      import_effect2.Effect.retry(
-        import_effect2.Schedule.compose(import_effect2.Schedule.exponential(50), import_effect2.Schedule.recurs(5))
+    return yield* (0, import_effect6.pipe)(
+      makeGet(pattern, schema, kupoHeader),
+      import_effect6.Effect.flatMap(import_effect6.Effect.fromNullable),
+      import_effect6.Effect.map((result) => result.datum),
+      import_effect6.Effect.retry(
+        import_effect6.Schedule.compose(import_effect6.Schedule.exponential(50), import_effect6.Schedule.recurs(5))
       ),
-      import_effect2.Effect.timeout(5e3)
+      import_effect6.Effect.timeout(5e3)
     );
   } else return void 0;
 });
-var getScriptEffect = (kupoUrl, script_hash) => import_effect2.Effect.gen(function* () {
+var getScriptEffect = (kupoUrl, script_hash, kupoHeader) => import_effect6.Effect.gen(function* () {
   if (script_hash) {
     const pattern = `${kupoUrl}/scripts/${script_hash}`;
     const schema = ScriptSchema;
-    return yield* (0, import_effect2.pipe)(
-      fetchKupoParse(pattern, schema),
-      import_effect2.Effect.flatMap(import_effect2.Effect.fromNullable),
-      import_effect2.Effect.retry(
-        import_effect2.Schedule.compose(import_effect2.Schedule.exponential(50), import_effect2.Schedule.recurs(5))
+    return yield* (0, import_effect6.pipe)(
+      makeGet(pattern, schema, kupoHeader),
+      import_effect6.Effect.flatMap(import_effect6.Effect.fromNullable),
+      import_effect6.Effect.retry(
+        import_effect6.Schedule.compose(import_effect6.Schedule.exponential(50), import_effect6.Schedule.recurs(5))
       ),
-      import_effect2.Effect.timeout(5e3),
-      import_effect2.Effect.map(({ language, script }) => {
+      import_effect6.Effect.timeout(5e3),
+      import_effect6.Effect.map(({ language, script }) => {
         switch (language) {
           case "native":
             return {
@@ -987,38 +1081,15 @@ var toProtocolParameters = (result) => {
     }
   };
 };
-var fetchOgmiosParse = (url, data, schema) => (0, import_effect2.pipe)(
-  import_platform.HttpClientRequest.post(url),
-  import_platform.HttpClientRequest.jsonBody(data),
-  import_effect2.Effect.flatMap(import_platform.HttpClient.fetch),
-  import_platform.HttpClientResponse.json,
-  import_effect2.Effect.flatMap(S3.decodeUnknown(schema)),
-  import_effect2.Effect.catchTag(
-    "ParseError",
-    (e) => import_effect2.Effect.fail(import_schema.ArrayFormatter.formatErrorSync(e))
-  )
-  // Effect.scoped
-);
-var fetchKupoParse = (url, schema) => (0, import_effect2.pipe)(
-  import_platform.HttpClientRequest.get(url),
-  import_platform.HttpClient.fetchOk,
-  import_platform.HttpClientResponse.json,
-  import_effect2.Effect.flatMap(S3.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_effect2.Effect.forEach(
+var kupmiosUtxosToUtxos = (kupoURL, utxos, kupoHeader) => import_effect6.Effect.forEach(
   utxos,
   (utxo) => {
-    return (0, import_effect2.pipe)(
-      import_effect2.Effect.all([
-        getDatumEffect(kupoURL, utxo.datum_type, utxo.datum_hash),
-        getScriptEffect(kupoURL, utxo.script_hash)
+    return (0, import_effect6.pipe)(
+      import_effect6.Effect.all([
+        getDatumEffect(kupoURL, utxo.datum_type, utxo.datum_hash, kupoHeader),
+        getScriptEffect(kupoURL, utxo.script_hash, kupoHeader)
       ]),
-      import_effect2.Effect.map(
+      import_effect6.Effect.map(
         ([datum, script]) => ({
           txHash: utxo.transaction_id,
           outputIndex: utxo.output_index,
@@ -2108,213 +2179,211 @@ var toScriptRef = (reference_script) => {
 var lucid2 = package_default.version;
 
 // src/koios.ts
-var S5 = __toESM(require("@effect/schema/Schema"), 1);
 var import_core_utils4 = require("@lucid-evolution/core-utils");
 var import_utils9 = require("@lucid-evolution/utils");
 
 // src/internal/koios.ts
-var import_platform2 = require("@effect/platform");
-var S4 = __toESM(require("@effect/schema/Schema"), 1);
-var import_effect3 = require("effect");
+var import_platform3 = require("@effect/platform");
+var import_effect7 = require("effect");
 var import_utils8 = require("@lucid-evolution/utils");
-var ProtocolParametersSchema2 = S4.Struct({
-  pvt_motion_no_confidence: S4.Number,
-  pvt_committee_normal: S4.Number,
-  pvt_committee_no_confidence: S4.Number,
-  pvt_hard_fork_initiation: S4.Number,
-  pvtpp_security_group: S4.Number,
-  dvt_motion_no_confidence: S4.Number,
-  dvt_committee_normal: S4.Number,
-  dvt_committee_no_confidence: S4.Number,
-  dvt_update_to_constitution: S4.Number,
-  dvt_hard_fork_initiation: S4.Number,
-  dvt_p_p_network_group: S4.Number,
-  dvt_p_p_economic_group: S4.Number,
-  dvt_p_p_technical_group: S4.Number,
-  dvt_p_p_gov_group: S4.Number,
-  dvt_treasury_withdrawal: S4.Number,
-  committee_min_size: S4.Number,
-  committee_max_term_length: S4.Number,
-  gov_action_lifetime: S4.Number,
-  gov_action_deposit: S4.NumberFromString,
-  drep_deposit: S4.NumberFromString,
-  drep_activity: S4.Number,
-  min_fee_ref_script_cost_per_byte: S4.Number,
-  epoch_no: S4.Number,
-  min_fee_a: S4.Number,
-  min_fee_b: S4.Number,
-  max_block_size: S4.Number,
-  max_tx_size: S4.Number,
-  max_bh_size: S4.Number,
-  key_deposit: S4.BigInt,
-  pool_deposit: S4.BigInt,
-  max_epoch: S4.Number,
-  optimal_pool_count: S4.Number,
-  influence: S4.Number,
-  monetary_expand_rate: S4.Number,
-  treasury_growth_rate: S4.Number,
-  decentralisation: S4.Number,
-  extra_entropy: S4.NullOr(S4.String),
-  protocol_major: S4.Number,
-  protocol_minor: S4.Number,
-  min_utxo_value: S4.String,
-  min_pool_cost: S4.String,
-  nonce: S4.String,
-  block_hash: S4.NullOr(S4.String),
-  cost_models: S4.Struct({
-    PlutusV1: S4.Array(S4.Number),
-    PlutusV2: S4.Array(S4.Number),
-    PlutusV3: S4.Array(S4.Number)
+var ProtocolParametersSchema2 = import_effect7.Schema.Struct({
+  pvt_motion_no_confidence: import_effect7.Schema.Number,
+  pvt_committee_normal: import_effect7.Schema.Number,
+  pvt_committee_no_confidence: import_effect7.Schema.Number,
+  pvt_hard_fork_initiation: import_effect7.Schema.Number,
+  pvtpp_security_group: import_effect7.Schema.Number,
+  dvt_motion_no_confidence: import_effect7.Schema.Number,
+  dvt_committee_normal: import_effect7.Schema.Number,
+  dvt_committee_no_confidence: import_effect7.Schema.Number,
+  dvt_update_to_constitution: import_effect7.Schema.Number,
+  dvt_hard_fork_initiation: import_effect7.Schema.Number,
+  dvt_p_p_network_group: import_effect7.Schema.Number,
+  dvt_p_p_economic_group: import_effect7.Schema.Number,
+  dvt_p_p_technical_group: import_effect7.Schema.Number,
+  dvt_p_p_gov_group: import_effect7.Schema.Number,
+  dvt_treasury_withdrawal: import_effect7.Schema.Number,
+  committee_min_size: import_effect7.Schema.Number,
+  committee_max_term_length: import_effect7.Schema.Number,
+  gov_action_lifetime: import_effect7.Schema.Number,
+  gov_action_deposit: import_effect7.Schema.NumberFromString,
+  drep_deposit: import_effect7.Schema.NumberFromString,
+  drep_activity: import_effect7.Schema.Number,
+  min_fee_ref_script_cost_per_byte: import_effect7.Schema.Number,
+  epoch_no: import_effect7.Schema.Number,
+  min_fee_a: import_effect7.Schema.Number,
+  min_fee_b: import_effect7.Schema.Number,
+  max_block_size: import_effect7.Schema.Number,
+  max_tx_size: import_effect7.Schema.Number,
+  max_bh_size: import_effect7.Schema.Number,
+  key_deposit: import_effect7.Schema.BigInt,
+  pool_deposit: import_effect7.Schema.BigInt,
+  max_epoch: import_effect7.Schema.Number,
+  optimal_pool_count: import_effect7.Schema.Number,
+  influence: import_effect7.Schema.Number,
+  monetary_expand_rate: import_effect7.Schema.Number,
+  treasury_growth_rate: import_effect7.Schema.Number,
+  decentralisation: import_effect7.Schema.Number,
+  extra_entropy: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  protocol_major: import_effect7.Schema.Number,
+  protocol_minor: import_effect7.Schema.Number,
+  min_utxo_value: import_effect7.Schema.String,
+  min_pool_cost: import_effect7.Schema.String,
+  nonce: import_effect7.Schema.String,
+  block_hash: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  cost_models: import_effect7.Schema.Struct({
+    PlutusV1: import_effect7.Schema.Array(import_effect7.Schema.Number),
+    PlutusV2: import_effect7.Schema.Array(import_effect7.Schema.Number),
+    PlutusV3: import_effect7.Schema.Array(import_effect7.Schema.Number)
   }),
-  price_mem: S4.Number,
-  price_step: S4.Number,
-  max_tx_ex_mem: S4.BigIntFromNumber,
-  max_tx_ex_steps: S4.BigIntFromNumber,
-  max_block_ex_mem: S4.Number,
-  max_block_ex_steps: S4.Number,
-  max_val_size: S4.Number,
-  collateral_percent: S4.Number,
-  max_collateral_inputs: S4.Number,
-  coins_per_utxo_size: S4.BigInt
+  price_mem: import_effect7.Schema.Number,
+  price_step: import_effect7.Schema.Number,
+  max_tx_ex_mem: import_effect7.Schema.BigIntFromNumber,
+  max_tx_ex_steps: import_effect7.Schema.BigIntFromNumber,
+  max_block_ex_mem: import_effect7.Schema.Number,
+  max_block_ex_steps: import_effect7.Schema.Number,
+  max_val_size: import_effect7.Schema.Number,
+  collateral_percent: import_effect7.Schema.Number,
+  max_collateral_inputs: import_effect7.Schema.Number,
+  coins_per_utxo_size: import_effect7.Schema.BigInt
 });
-var AssetSchema = S4.Struct({
-  policy_id: S4.String,
-  asset_name: S4.NullOr(S4.String),
-  fingerprint: S4.String,
-  decimals: S4.Number,
-  quantity: S4.String
+var AssetSchema = import_effect7.Schema.Struct({
+  policy_id: import_effect7.Schema.String,
+  asset_name: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  fingerprint: import_effect7.Schema.String,
+  decimals: import_effect7.Schema.Number,
+  quantity: import_effect7.Schema.String
 });
-var ReferenceScriptSchema = S4.Struct({
-  hash: S4.NullOr(S4.String),
-  size: S4.NullOr(S4.Number),
-  type: S4.NullOr(S4.String),
-  bytes: S4.NullOr(S4.String),
-  value: S4.NullOr(S4.Object)
+var ReferenceScriptSchema = import_effect7.Schema.Struct({
+  hash: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  size: import_effect7.Schema.NullOr(import_effect7.Schema.Number),
+  type: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  bytes: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  value: import_effect7.Schema.NullOr(import_effect7.Schema.Object)
 });
-var UTxOSchema2 = S4.Struct({
-  tx_hash: S4.String,
-  tx_index: S4.Number,
-  block_time: S4.Number,
-  block_height: S4.NullOr(S4.Number),
-  value: S4.String,
-  datum_hash: S4.NullOr(S4.String),
-  inline_datum: S4.NullOr(
-    S4.Struct({
-      bytes: S4.String,
-      value: S4.Object
+var UTxOSchema2 = import_effect7.Schema.Struct({
+  tx_hash: import_effect7.Schema.String,
+  tx_index: import_effect7.Schema.Number,
+  block_time: import_effect7.Schema.Number,
+  block_height: import_effect7.Schema.NullOr(import_effect7.Schema.Number),
+  value: import_effect7.Schema.String,
+  datum_hash: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  inline_datum: import_effect7.Schema.NullOr(
+    import_effect7.Schema.Struct({
+      bytes: import_effect7.Schema.String,
+      value: import_effect7.Schema.Object
     })
   ),
-  reference_script: S4.NullOr(ReferenceScriptSchema),
-  asset_list: S4.NullOr(S4.Array(AssetSchema))
+  reference_script: import_effect7.Schema.NullOr(ReferenceScriptSchema),
+  asset_list: import_effect7.Schema.NullOr(import_effect7.Schema.Array(AssetSchema))
 });
-var AddressInfoSchema = S4.Array(
-  S4.NullishOr(
-    S4.Struct({
-      address: S4.String,
-      balance: S4.String,
-      stake_address: S4.NullOr(S4.String),
-      script_address: S4.Boolean,
-      utxo_set: S4.Array(UTxOSchema2)
+var AddressInfoSchema = import_effect7.Schema.Array(
+  import_effect7.Schema.NullishOr(
+    import_effect7.Schema.Struct({
+      address: import_effect7.Schema.String,
+      balance: import_effect7.Schema.String,
+      stake_address: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+      script_address: import_effect7.Schema.Boolean,
+      utxo_set: import_effect7.Schema.Array(UTxOSchema2)
     })
   )
 );
-var InputOutputSchema = S4.Struct({
-  payment_addr: S4.Struct({
-    bech32: S4.String,
-    cred: S4.String
+var InputOutputSchema = import_effect7.Schema.Struct({
+  payment_addr: import_effect7.Schema.Struct({
+    bech32: import_effect7.Schema.String,
+    cred: import_effect7.Schema.String
   }),
-  stake_addr: S4.NullOr(S4.String),
-  tx_hash: S4.String,
-  tx_index: S4.Number,
-  value: S4.String,
-  datum_hash: S4.NullOr(S4.String),
-  inline_datum: S4.NullOr(
-    S4.Struct({
-      bytes: S4.String,
-      value: S4.Object
+  stake_addr: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  tx_hash: import_effect7.Schema.String,
+  tx_index: import_effect7.Schema.Number,
+  value: import_effect7.Schema.String,
+  datum_hash: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  inline_datum: import_effect7.Schema.NullOr(
+    import_effect7.Schema.Struct({
+      bytes: import_effect7.Schema.String,
+      value: import_effect7.Schema.Object
     })
   ),
-  reference_script: S4.NullOr(ReferenceScriptSchema),
-  asset_list: S4.Array(AssetSchema)
+  reference_script: import_effect7.Schema.NullOr(ReferenceScriptSchema),
+  asset_list: import_effect7.Schema.Array(AssetSchema)
 });
-var TxInfoSchema = S4.Struct({
-  tx_hash: S4.String,
-  block_hash: S4.String,
-  block_height: S4.Number,
-  epoch_no: S4.Number,
-  epoch_slot: S4.Number,
-  absolute_slot: S4.Number,
-  tx_timestamp: S4.Number,
-  tx_block_index: S4.Number,
-  tx_size: S4.Number,
-  total_output: S4.String,
-  fee: S4.String,
-  treasury_donation: S4.String,
-  deposit: S4.String,
-  invalid_before: S4.NullOr(S4.String),
-  invalid_after: S4.NullOr(S4.String),
-  collateral_inputs: S4.NullOr(S4.Array(InputOutputSchema)),
-  collateral_output: S4.NullOr(InputOutputSchema),
-  reference_inputs: S4.NullOr(S4.Array(InputOutputSchema)),
-  inputs: S4.Array(InputOutputSchema),
-  outputs: S4.Array(InputOutputSchema),
-  withdrawals: S4.NullOr(
-    S4.Array(
-      S4.Struct({
-        amount: S4.String,
-        stake_addr: S4.String
+var TxInfoSchema = import_effect7.Schema.Struct({
+  tx_hash: import_effect7.Schema.String,
+  block_hash: import_effect7.Schema.String,
+  block_height: import_effect7.Schema.Number,
+  epoch_no: import_effect7.Schema.Number,
+  epoch_slot: import_effect7.Schema.Number,
+  absolute_slot: import_effect7.Schema.Number,
+  tx_timestamp: import_effect7.Schema.Number,
+  tx_block_index: import_effect7.Schema.Number,
+  tx_size: import_effect7.Schema.Number,
+  total_output: import_effect7.Schema.String,
+  fee: import_effect7.Schema.String,
+  treasury_donation: import_effect7.Schema.String,
+  deposit: import_effect7.Schema.String,
+  invalid_before: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  invalid_after: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  collateral_inputs: import_effect7.Schema.NullOr(import_effect7.Schema.Array(InputOutputSchema)),
+  collateral_output: import_effect7.Schema.NullOr(InputOutputSchema),
+  reference_inputs: import_effect7.Schema.NullOr(import_effect7.Schema.Array(InputOutputSchema)),
+  inputs: import_effect7.Schema.Array(InputOutputSchema),
+  outputs: import_effect7.Schema.Array(InputOutputSchema),
+  withdrawals: import_effect7.Schema.NullOr(
+    import_effect7.Schema.Array(
+      import_effect7.Schema.Struct({
+        amount: import_effect7.Schema.String,
+        stake_addr: import_effect7.Schema.String
       })
     )
   ),
-  assets_minted: S4.NullOr(S4.Array(AssetSchema)),
-  metadata: S4.NullOr(S4.Object),
-  certificates: S4.NullOr(
-    S4.Array(
-      S4.Struct({
-        index: S4.Number,
-        type: S4.String,
-        info: S4.NullOr(S4.Object)
+  assets_minted: import_effect7.Schema.NullOr(import_effect7.Schema.Array(AssetSchema)),
+  metadata: import_effect7.Schema.NullOr(import_effect7.Schema.Object),
+  certificates: import_effect7.Schema.NullOr(
+    import_effect7.Schema.Array(
+      import_effect7.Schema.Struct({
+        index: import_effect7.Schema.Number,
+        type: import_effect7.Schema.String,
+        info: import_effect7.Schema.NullOr(import_effect7.Schema.Object)
       })
     )
   ),
-  native_scripts: S4.NullOr(
-    S4.Array(
-      S4.Struct({
-        script_hash: S4.String,
-        script_json: S4.Object
+  native_scripts: import_effect7.Schema.NullOr(
+    import_effect7.Schema.Array(
+      import_effect7.Schema.Struct({
+        script_hash: import_effect7.Schema.String,
+        script_json: import_effect7.Schema.Object
       })
     )
   ),
-  plutus_contracts: S4.NullOr(
-    S4.Array(
-      S4.Struct({
-        address: S4.String,
-        spends_input: S4.NullOr(
-          S4.Struct({
-            tx_hash: S4.String,
-            tx_index: S4.Number
+  plutus_contracts: import_effect7.Schema.NullOr(
+    import_effect7.Schema.Array(
+      import_effect7.Schema.Struct({
+        address: import_effect7.Schema.String,
+        spends_input: import_effect7.Schema.NullOr(
+          import_effect7.Schema.Struct({
+            tx_hash: import_effect7.Schema.String,
+            tx_index: import_effect7.Schema.Number
           })
         ),
-        script_hash: S4.String,
-        bytecode: S4.String,
-        size: S4.Number,
-        valid_contract: S4.Boolean,
-        input: S4.Struct({
-          redeemer: S4.Struct({
-            purpose: S4.Literal("spend", "mint", "cert", "reward"),
-            fee: S4.String,
-            unit: S4.Struct({
-              steps: S4.String,
-              mem: S4.String
+        script_hash: import_effect7.Schema.String,
+        bytecode: import_effect7.Schema.String,
+        size: import_effect7.Schema.Number,
+        valid_contract: import_effect7.Schema.Boolean,
+        input: import_effect7.Schema.Struct({
+          redeemer: import_effect7.Schema.Struct({
+            purpose: import_effect7.Schema.Literal("spend", "mint", "cert", "reward"),
+            fee: import_effect7.Schema.String,
+            unit: import_effect7.Schema.Struct({
+              steps: import_effect7.Schema.String,
+              mem: import_effect7.Schema.String
             }),
-            datum: S4.Struct({
-              hash: S4.NullOr(S4.String),
-              value: S4.NullOr(S4.Object)
+            datum: import_effect7.Schema.Struct({
+              hash: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+              value: import_effect7.Schema.NullOr(import_effect7.Schema.Object)
             })
           }),
-          datum: S4.Struct({
-            hash: S4.NullOr(S4.String),
-            value: S4.NullOr(S4.Object)
+          datum: import_effect7.Schema.Struct({
+            hash: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+            value: import_effect7.Schema.NullOr(import_effect7.Schema.Object)
           })
         })
       })
@@ -2322,45 +2391,24 @@ var TxInfoSchema = S4.Struct({
   ),
   //TODO: add S.Struct
   // https://preprod.koios.rest/#post-/tx_info
-  voting_procedures: S4.Array(S4.Object),
+  voting_procedures: import_effect7.Schema.Array(import_effect7.Schema.Object),
   //TODO: add S.Struct
   // https://preprod.koios.rest/#post-/tx_info
-  proposal_procedures: S4.Object
+  proposal_procedures: import_effect7.Schema.Object
 });
-var TxHashSchema = S4.String;
-var AssetAddressSchema = S4.Struct({
-  payment_address: S4.String,
-  stake_address: S4.NullOr(S4.String),
-  quantity: S4.String
+var TxHashSchema = import_effect7.Schema.String;
+var AssetAddressSchema = import_effect7.Schema.Struct({
+  payment_address: import_effect7.Schema.String,
+  stake_address: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  quantity: import_effect7.Schema.String
 });
-var AccountInfoSchema = S4.Struct({
-  delegated_pool: S4.NullOr(S4.String),
-  rewards_available: S4.NumberFromString
+var AccountInfoSchema = import_effect7.Schema.Struct({
+  delegated_pool: import_effect7.Schema.NullOr(import_effect7.Schema.String),
+  rewards_available: import_effect7.Schema.NumberFromString
 });
-var DatumInfo = S4.Struct({
-  bytes: S4.String
+var DatumInfo = import_effect7.Schema.Struct({
+  bytes: import_effect7.Schema.String
 });
-var postWithSchemaValidation = (url, data, schema, headers = {}) => (0, import_effect3.pipe)(
-  import_effect3.Effect.succeed(import_platform2.HttpClientRequest.post(url)),
-  import_effect3.Effect.map(import_platform2.HttpClientRequest.setHeaders(headers)),
-  import_effect3.Effect.flatMap(
-    (req) => headers["Content-Type"] === "application/cbor" ? import_effect3.Effect.succeed(
-      import_platform2.HttpClientRequest.uint8ArrayBody(
-        data,
-        headers["Content-Type"]
-      )(req)
-    ) : import_platform2.HttpClientRequest.jsonBody(data)(req)
-  ),
-  import_effect3.Effect.flatMap(import_platform2.HttpClient.fetch),
-  import_platform2.HttpClientResponse.json,
-  import_effect3.Effect.flatMap(S4.decodeUnknown(schema))
-);
-var getWithSchemaValidation = (url, schema) => (0, import_effect3.pipe)(
-  import_platform2.HttpClientRequest.get(url),
-  import_platform2.HttpClient.fetchOk,
-  import_platform2.HttpClientResponse.json,
-  import_effect3.Effect.flatMap(S4.decodeUnknown(schema))
-);
 var toUTxO = (koiosUTxO, address) => ({
   txHash: koiosUTxO.tx_hash,
   outputIndex: koiosUTxO.tx_index,
@@ -2402,44 +2450,51 @@ 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 = (0, import_effect3.pipe)(
-    import_effect3.Effect.if(typeof addressOrCredential === "string", {
-      onFalse: () => import_effect3.Effect.fail("Credential Type is not supported in Koios yet."),
-      onTrue: () => postWithSchemaValidation(url, body, schema)
+  const result = (0, import_effect7.pipe)(
+    import_effect7.Effect.if(typeof addressOrCredential === "string", {
+      onFalse: () => import_effect7.Effect.fail("Credential Type is not supported in Koios yet."),
+      onTrue: () => makePostAsJson(url, body, schema, headers)
     }),
-    import_effect3.Effect.map(
+    import_effect7.Effect.map(
       ([result2]) => result2 ? result2.utxo_set.map((koiosUtxo) => toUTxO(koiosUtxo, result2.address)) : []
-    )
+    ),
+    import_effect7.Effect.provide(import_platform3.FetchHttpClient.layer)
   );
   return result;
 };
 
 // src/koios.ts
-var import_effect4 = require("effect");
-var KoiosError = class extends import_effect4.Data.TaggedError("KoiosError") {
+var import_effect8 = require("effect");
+var import_platform4 = require("@effect/platform");
+var KoiosError = class extends import_effect8.Data.TaggedError("KoiosError") {
   get message() {
     return `${this.cause}`;
   }
 };
 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 (0, import_effect4.pipe)(
-      getWithSchemaValidation(url, schema),
-      import_effect4.Effect.timeout(1e4),
-      import_effect4.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect4.Effect.runPromise
+    const schema = import_effect8.Schema.Array(ProtocolParametersSchema2);
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const [result] = await (0, import_effect8.pipe)(
+      makeGet(url, schema, bearerToken),
+      // Allows for dependency injection and easier testing
+      import_effect8.Effect.provide(import_platform4.FetchHttpClient.layer),
+      import_effect8.Effect.timeout(1e4),
+      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
+      import_effect8.Effect.runPromise
     );
     return {
       minFeeA: result.min_fee_a,
@@ -2481,55 +2536,64 @@ var Koios = class {
     };
   }
   async getUtxos(addressOrCredential) {
-    const result = await (0, import_effect4.pipe)(
-      getUtxosEffect(this.baseUrl, addressOrCredential),
-      import_effect4.Effect.timeout(1e4),
-      import_effect4.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect4.Effect.runPromise
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await (0, import_effect8.pipe)(
+      getUtxosEffect(this.baseUrl, addressOrCredential, bearerToken),
+      import_effect8.Effect.timeout(1e4),
+      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
+      import_effect8.Effect.runPromise
     );
     return result;
   }
   async getUtxosWithUnit(addressOrCredential, unit) {
-    const result = await (0, import_effect4.pipe)(
-      getUtxosEffect(this.baseUrl, addressOrCredential),
-      import_effect4.Effect.map(
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await (0, import_effect8.pipe)(
+      getUtxosEffect(this.baseUrl, addressOrCredential, bearerToken),
+      import_effect8.Effect.map(
         (utxos) => utxos.filter((utxo) => {
           const keys = Object.keys(utxo.assets);
           return keys.length > 0 && keys.includes(unit);
         })
       ),
-      import_effect4.Effect.timeout(1e4),
-      import_effect4.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect4.Effect.runPromise
+      import_effect8.Effect.timeout(1e4),
+      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
+      import_effect8.Effect.runPromise
     );
     return result;
   }
   async getUtxoByUnit(unit) {
     let { policyId, assetName } = (0, import_utils9.fromUnit)(unit);
     const url = `${this.baseUrl}/asset_addresses?_asset_policy=${policyId}&_asset_name=${assetName}`;
-    const result = await (0, import_effect4.pipe)(
-      getWithSchemaValidation(url, S5.Array(AssetAddressSchema)),
-      import_effect4.Effect.flatMap(
-        (adresses) => adresses.length === 0 ? import_effect4.Effect.fail("Unit not found") : import_effect4.Effect.succeed(adresses)
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await (0, import_effect8.pipe)(
+      makeGet(url, import_effect8.Schema.Array(AssetAddressSchema), bearerToken),
+      // Allows for dependency injection and easier testing
+      import_effect8.Effect.provide(import_platform4.FetchHttpClient.layer),
+      import_effect8.Effect.flatMap(
+        (adresses) => adresses.length === 0 ? import_effect8.Effect.fail("Unit not found") : import_effect8.Effect.succeed(adresses)
       ),
-      import_effect4.Effect.flatMap(
-        (adresses) => adresses.length > 1 ? import_effect4.Effect.fail("Unit needs to be an NFT or only held by one address.") : import_effect4.Effect.succeed(adresses[0])
+      import_effect8.Effect.flatMap(
+        (adresses) => adresses.length > 1 ? import_effect8.Effect.fail("Unit needs to be an NFT or only held by one address.") : import_effect8.Effect.succeed(adresses[0])
       ),
-      import_effect4.Effect.flatMap(
-        (address) => getUtxosEffect(this.baseUrl, address.payment_address)
+      import_effect8.Effect.flatMap(
+        (address) => getUtxosEffect(
+          this.baseUrl,
+          address.payment_address,
+          bearerToken
+        )
       ),
-      import_effect4.Effect.map(
+      import_effect8.Effect.map(
         (utxos) => utxos.filter((utxo) => {
           const keys = Object.keys(utxo.assets);
           return keys.length > 0 && keys.includes(unit);
         })
       ),
-      import_effect4.Effect.flatMap(
-        (utxos) => utxos.length > 1 ? import_effect4.Effect.fail("Unit needs to be an NFT or only held by one address.") : import_effect4.Effect.succeed(utxos[0])
+      import_effect8.Effect.flatMap(
+        (utxos) => utxos.length > 1 ? import_effect8.Effect.fail("Unit needs to be an NFT or only held by one address.") : import_effect8.Effect.succeed(utxos[0])
       ),
-      import_effect4.Effect.timeout(1e4),
-      import_effect4.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect4.Effect.runPromise
+      import_effect8.Effect.timeout(1e4),
+      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
+      import_effect8.Effect.runPromise
     );
     return result;
   }
@@ -2540,12 +2604,15 @@ var Koios = class {
       _assets: true,
       _scripts: true
     };
-    const schema = S5.Array(TxInfoSchema);
-    const [result] = await (0, import_effect4.pipe)(
-      postWithSchemaValidation(url, body, schema),
-      import_effect4.Effect.timeout(1e4),
-      import_effect4.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect4.Effect.runPromise
+    const schema = import_effect8.Schema.Array(TxInfoSchema);
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const [result] = await (0, import_effect8.pipe)(
+      makePostAsJson(url, body, schema, bearerToken),
+      // Allows for dependency injection and easier testing
+      import_effect8.Effect.provide(import_platform4.FetchHttpClient.layer),
+      import_effect8.Effect.timeout(1e4),
+      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
+      import_effect8.Effect.runPromise
     );
     if (result) {
       const utxos = result.outputs.map(
@@ -2578,18 +2645,22 @@ var Koios = class {
       _stake_addresses: [rewardAddress]
     };
     const url = `${this.baseUrl}/account_info`;
-    const result = await (0, import_effect4.pipe)(
-      postWithSchemaValidation(
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await (0, import_effect8.pipe)(
+      makePostAsJson(
         url,
         body,
-        S5.Array(AccountInfoSchema)
+        import_effect8.Schema.Array(AccountInfoSchema),
+        bearerToken
       ),
-      import_effect4.Effect.flatMap(
-        (result2) => result2.length === 0 ? import_effect4.Effect.fail("No Delegation Found by Reward Address") : import_effect4.Effect.succeed(result2[0])
+      // Allows for dependency injection and easier testing
+      import_effect8.Effect.provide(import_platform4.FetchHttpClient.layer),
+      import_effect8.Effect.flatMap(
+        (result2) => result2.length === 0 ? import_effect8.Effect.fail("No Delegation Found by Reward Address") : import_effect8.Effect.succeed(result2[0])
       ),
-      import_effect4.Effect.timeout(1e4),
-      import_effect4.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect4.Effect.runPromise
+      import_effect8.Effect.timeout(1e4),
+      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
+      import_effect8.Effect.runPromise
     );
     return {
       poolId: result.delegated_pool || null,
@@ -2601,14 +2672,22 @@ var Koios = class {
     const body = {
       _datum_hashes: [datumHash]
     };
-    const result = await (0, import_effect4.pipe)(
-      postWithSchemaValidation(url, body, S5.Array(DatumInfo)),
-      import_effect4.Effect.flatMap(
-        (result2) => result2.length === 0 ? import_effect4.Effect.fail("No Datum Found by Datum Hash") : import_effect4.Effect.succeed(result2[0])
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await (0, import_effect8.pipe)(
+      makePostAsJson(
+        url,
+        body,
+        import_effect8.Schema.Array(DatumInfo),
+        bearerToken
       ),
-      import_effect4.Effect.timeout(1e4),
-      import_effect4.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect4.Effect.runPromise
+      // Allows for dependency injection and easier testing
+      import_effect8.Effect.provide(import_platform4.FetchHttpClient.layer),
+      import_effect8.Effect.flatMap(
+        (result2) => result2.length === 0 ? import_effect8.Effect.fail("No Datum Found by Datum Hash") : import_effect8.Effect.succeed(result2[0])
+      ),
+      import_effect8.Effect.timeout(1e4),
+      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
+      import_effect8.Effect.runPromise
     );
     return result.bytes;
   }
@@ -2617,17 +2696,20 @@ var Koios = class {
     const body = {
       _tx_hashes: [txHash]
     };
-    const schema = S5.Array(TxInfoSchema);
-    const result = await (0, import_effect4.pipe)(
-      postWithSchemaValidation(url, body, schema),
-      import_effect4.Effect.repeat({
-        schedule: import_effect4.Schedule.exponential(checkInterval),
+    const schema = import_effect8.Schema.Array(TxInfoSchema);
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await (0, import_effect8.pipe)(
+      makePostAsJson(url, body, schema, bearerToken),
+      import_effect8.Effect.repeat({
+        schedule: import_effect8.Schedule.exponential(checkInterval),
         until: (result2) => result2.length > 0
       }),
-      import_effect4.Effect.timeout(16e4),
-      import_effect4.Effect.orDie,
-      import_effect4.Effect.as(true),
-      import_effect4.Effect.runPromise
+      // Allows for dependency injection and easier testing
+      import_effect8.Effect.provide(import_platform4.FetchHttpClient.layer),
+      import_effect8.Effect.timeout(16e4),
+      import_effect8.Effect.orDie,
+      import_effect8.Effect.as(true),
+      import_effect8.Effect.runPromise
     );
     return result;
   }
@@ -2635,13 +2717,14 @@ var Koios = class {
     const url = `${this.baseUrl}/submittx`;
     const body = (0, import_core_utils4.fromHex)(tx);
     const schema = TxHashSchema;
-    const result = await (0, import_effect4.pipe)(
-      postWithSchemaValidation(url, body, schema, {
-        "Content-Type": "application/cbor"
-      }),
-      import_effect4.Effect.timeout(1e4),
-      import_effect4.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect4.Effect.runPromise
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const result = await (0, import_effect8.pipe)(
+      makePostAsUint8Array(url, body, schema, bearerToken),
+      // Allows for dependency injection and easier testing
+      import_effect8.Effect.provide(import_platform4.FetchHttpClient.layer),
+      import_effect8.Effect.timeout(1e4),
+      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
+      import_effect8.Effect.runPromise
     );
     return result;
   }
@@ -2656,15 +2739,15 @@ var Koios = class {
       },
       id: null
     };
-    const schema = JSONRPCSchema(S5.Array(RedeemerSchema));
-    const result = await (0, import_effect4.pipe)(
-      postWithSchemaValidation(url, body, schema),
-      import_effect4.Effect.flatMap(
-        (response) => "error" in response ? import_effect4.Effect.fail(response) : import_effect4.Effect.succeed(response.result)
-      ),
-      import_effect4.Effect.timeout(1e4),
-      import_effect4.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect4.Effect.runPromise
+    const schema = JSONRPCSchema(import_effect8.Schema.Array(RedeemerSchema));
+    const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
+    const { result } = await (0, import_effect8.pipe)(
+      makePostAsJson(url, body, schema, bearerToken),
+      // Allows for dependency injection and easier testing
+      import_effect8.Effect.provide(import_platform4.FetchHttpClient.layer),
+      import_effect8.Effect.timeout(1e4),
+      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
+      import_effect8.Effect.runPromise
     );
     const evalRedeemers = result.map((item) => ({
       ex_units: {