@lucid-evolution/provider 0.4.0 → 0.4.1

package/dist/index.cjs

@@ -143,7 +143,7 @@ var import_utils2 = require("@lucid-evolution/utils");
 // package.json
 var package_default = {
   name: "@lucid-evolution/provider",
-  version: "0.4.0",
+  version: "0.4.1",
   description: "",
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
@@ -188,7 +188,8 @@ var package_default = {
 };
 
 // src/internal/blockfrost.ts
-var import_effect = require("effect");
+var Record = __toESM(require("effect/Record"), 1);
+var import_Function = require("effect/Function");
 var import_utils = require("@lucid-evolution/utils");
 var toAditionalUTXOs = (utxos) => (utxos || []).map((utxo) => [
   {
@@ -220,7 +221,7 @@ var toTxOutScript = (scriptRef) => {
     }
   }
 };
-var fromAssets = (assets) => (0, import_effect.pipe)(import_effect.Record.remove(assets, "lovelace"), (nativeAssets) => {
+var fromAssets = (assets) => (0, import_Function.pipe)(Record.remove(assets, "lovelace"), (nativeAssets) => {
   const result = {};
   for (const [unit, amount] of Object.entries(nativeAssets)) {
     const policyId = unit.slice(0, 56);
@@ -259,16 +260,16 @@ var Blockfrost = class {
   constructor(url, projectId, options = {}) {
     this.url = url;
     this.projectId = projectId || "";
-    const timeout = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-    if (!Number.isFinite(timeout) || timeout <= 0) {
+    const timeout3 = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    if (!Number.isFinite(timeout3) || timeout3 <= 0) {
       throw new TypeError("requestTimeoutMs must be a positive finite number.");
     }
-    this.requestTimeoutMs = timeout;
+    this.requestTimeoutMs = timeout3;
   }
   /** `fetch` bounded by the provider's request timeout, combined with any caller-supplied signal. */
   fetch(input, init = {}) {
-    const timeout = AbortSignal.timeout(this.requestTimeoutMs);
-    const signal = init.signal == null ? timeout : typeof AbortSignal.any === "function" ? AbortSignal.any([init.signal, timeout]) : init.signal;
+    const timeout3 = AbortSignal.timeout(this.requestTimeoutMs);
+    const signal = init.signal == null ? timeout3 : typeof AbortSignal.any === "function" ? AbortSignal.any([init.signal, timeout3]) : init.signal;
     return fetch(input, { ...init, signal });
   }
   async getProtocolParameters() {
@@ -599,30 +600,36 @@ var lucid = package_default.version;
 
 // src/kupmios.ts
 var import_utils4 = require("@lucid-evolution/utils");
-var import_effect5 = require("effect");
-var import_effect6 = require("effect");
+var S3 = __toESM(require("effect/Schema"), 1);
+var Cause = __toESM(require("effect/Cause"), 1);
+var Effect2 = __toESM(require("effect/Effect"), 1);
+var Exit = __toESM(require("effect/Exit"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var _Array = __toESM(require("effect/Array"), 1);
+var Schedule = __toESM(require("effect/Schedule"), 1);
+var import_Function3 = require("effect/Function");
 
 // src/internal/ogmios.ts
-var import_effect2 = require("effect");
+var S = __toESM(require("effect/Schema"), 1);
 var import_utils3 = require("@lucid-evolution/utils");
-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),
+var JSONRPCSchema = (schema) => S.Struct({
+  jsonrpc: S.String,
+  method: S.optional(S.String),
+  id: S.NullOr(S.Number),
   result: schema
 }).annotations({ identifier: "JSONRPCSchema" });
-var JSONRPCErrorSchema = import_effect2.Schema.Struct({
-  code: import_effect2.Schema.Number,
-  message: import_effect2.Schema.String,
-  data: import_effect2.Schema.optional(import_effect2.Schema.Unknown)
+var JSONRPCErrorSchema = S.Struct({
+  code: S.Number,
+  message: S.String,
+  data: S.optional(S.Unknown)
 });
-var JSONRPCErrorResponseSchema = 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),
+var JSONRPCErrorResponseSchema = S.Struct({
+  jsonrpc: S.String,
+  method: S.optional(S.String),
+  id: S.NullOr(S.Number),
   error: JSONRPCErrorSchema
 });
-var JSONRPCResponseSchema = (schema) => import_effect2.Schema.Union(JSONRPCSchema(schema), JSONRPCErrorResponseSchema).annotations({
+var JSONRPCResponseSchema = (schema) => S.Union(JSONRPCSchema(schema), JSONRPCErrorResponseSchema).annotations({
   identifier: "JSONRPCResponseSchema"
 });
 var getJSONRPCResult = (response, operation, transport) => {
@@ -650,18 +657,18 @@ var getJSONRPCResult = (response, operation, transport) => {
   }
   return response.result;
 };
-var LovelaceAsset = import_effect2.Schema.Struct({
-  lovelace: import_effect2.Schema.Number
+var LovelaceAsset = S.Struct({
+  lovelace: S.Number
 });
-var LovelaceAmount = import_effect2.Schema.Union(import_effect2.Schema.Number, import_effect2.Schema.String, import_effect2.Schema.BigInt);
-var TreasuryAndReservesSchema = import_effect2.Schema.Struct({
-  treasury: import_effect2.Schema.Struct({
-    ada: import_effect2.Schema.Struct({
+var LovelaceAmount = S.Union(S.Number, S.String, S.BigInt);
+var TreasuryAndReservesSchema = S.Struct({
+  treasury: S.Struct({
+    ada: S.Struct({
       lovelace: LovelaceAmount
     })
   }),
-  reserves: import_effect2.Schema.Struct({
-    ada: import_effect2.Schema.Struct({
+  reserves: S.Struct({
+    ada: S.Struct({
       lovelace: LovelaceAmount
     })
   })
@@ -676,12 +683,12 @@ var lovelaceAmountToBigInt = (lovelace) => {
   }
   return BigInt(lovelace);
 };
-var TupleNumberFromString = import_effect2.Schema.compose(
-  import_effect2.Schema.split("/"),
-  import_effect2.Schema.Array(import_effect2.Schema.NumberFromString)
+var TupleNumberFromString = S.compose(
+  S.split("/"),
+  S.Array(S.NumberFromString)
 );
-var MaxReferenceScriptsSizeSchema = import_effect2.Schema.Struct({
-  bytes: import_effect2.Schema.Number
+var MaxReferenceScriptsSizeSchema = S.Struct({
+  bytes: S.Number
 });
 function normalizeProtocolParameters(value) {
   const legacy = value.maxReferenceScriptsSize;
@@ -689,7 +696,7 @@ function normalizeProtocolParameters(value) {
   if (legacy === void 0 && current === void 0) {
     return value;
   }
-  const decode = import_effect2.Schema.decodeUnknownSync(MaxReferenceScriptsSizeSchema);
+  const decode = S.decodeUnknownSync(MaxReferenceScriptsSizeSchema);
   const legacyValue = legacy === void 0 ? void 0 : decode(legacy);
   const currentValue = current === void 0 ? void 0 : decode(current);
   if (legacyValue !== void 0 && currentValue !== void 0 && legacyValue.bytes !== currentValue.bytes) {
@@ -702,34 +709,34 @@ function normalizeProtocolParameters(value) {
     maxReferenceScriptsSize: legacyValue ?? currentValue
   };
 }
-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
+var ProtocolParametersSchema = S.Struct({
+  minFeeCoefficient: S.Number,
+  minFeeReferenceScripts: S.Struct({
+    base: S.Number,
+    range: S.Number,
+    multiplier: S.Number
   }),
   maxReferenceScriptsSize: MaxReferenceScriptsSizeSchema,
-  stakePoolVotingThresholds: import_effect2.Schema.Struct({
+  stakePoolVotingThresholds: S.Struct({
     noConfidence: TupleNumberFromString,
-    constitutionalCommittee: import_effect2.Schema.Struct({
+    constitutionalCommittee: S.Struct({
       default: TupleNumberFromString,
       stateOfNoConfidence: TupleNumberFromString
     }),
     hardForkInitiation: TupleNumberFromString,
-    protocolParametersUpdate: import_effect2.Schema.Struct({
+    protocolParametersUpdate: S.Struct({
       security: TupleNumberFromString
     })
   }),
-  delegateRepresentativeVotingThresholds: import_effect2.Schema.Struct({
+  delegateRepresentativeVotingThresholds: S.Struct({
     noConfidence: TupleNumberFromString,
-    constitutionalCommittee: import_effect2.Schema.Struct({
+    constitutionalCommittee: S.Struct({
       default: TupleNumberFromString,
       stateOfNoConfidence: TupleNumberFromString
     }),
     constitution: TupleNumberFromString,
     hardForkInitiation: TupleNumberFromString,
-    protocolParametersUpdate: import_effect2.Schema.Struct({
+    protocolParametersUpdate: S.Struct({
       network: TupleNumberFromString,
       economic: TupleNumberFromString,
       technical: TupleNumberFromString,
@@ -737,71 +744,71 @@ var ProtocolParametersSchema = import_effect2.Schema.Struct({
     }),
     treasuryWithdrawals: TupleNumberFromString
   }),
-  constitutionalCommitteeMinSize: import_effect2.Schema.optional(import_effect2.Schema.Number),
-  constitutionalCommitteeMaxTermLength: import_effect2.Schema.Number,
-  governanceActionLifetime: import_effect2.Schema.Number,
-  governanceActionDeposit: import_effect2.Schema.Struct({
+  constitutionalCommitteeMinSize: S.optional(S.Number),
+  constitutionalCommitteeMaxTermLength: S.Number,
+  governanceActionLifetime: S.Number,
+  governanceActionDeposit: S.Struct({
     ada: LovelaceAsset
   }),
-  delegateRepresentativeDeposit: import_effect2.Schema.Struct({
+  delegateRepresentativeDeposit: S.Struct({
     ada: LovelaceAsset
   }),
-  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,
+  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,
   stakePoolPledgeInfluence: TupleNumberFromString,
   monetaryExpansion: TupleNumberFromString,
   treasuryExpansion: TupleNumberFromString,
-  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)
+  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)
   }),
-  scriptExecutionPrices: import_effect2.Schema.Struct({
+  scriptExecutionPrices: S.Struct({
     memory: TupleNumberFromString,
     cpu: TupleNumberFromString
   }),
-  maxExecutionUnitsPerTransaction: import_effect2.Schema.Struct({
-    memory: import_effect2.Schema.Number,
-    cpu: import_effect2.Schema.Number
+  maxExecutionUnitsPerTransaction: S.Struct({
+    memory: S.Number,
+    cpu: 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 })
+  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 })
 }).annotations({ identifier: "ProtocolParametersSchema" });
-var RewardAccountAdaSchema = import_effect2.Schema.Struct({
+var RewardAccountAdaSchema = S.Struct({
   ada: LovelaceAsset
 });
-var LegacyDelegationSummarySchema = import_effect2.Schema.Struct({
-  delegate: import_effect2.Schema.optional(import_effect2.Schema.NullOr(import_effect2.Schema.Struct({ id: import_effect2.Schema.String }))),
+var LegacyDelegationSummarySchema = S.Struct({
+  delegate: S.optional(S.NullOr(S.Struct({ id: S.String }))),
   rewards: RewardAccountAdaSchema,
   deposit: RewardAccountAdaSchema
 });
-var RewardAccountSummarySchema = import_effect2.Schema.Struct({
-  from: import_effect2.Schema.optional(import_effect2.Schema.Literal("key", "verificationKey", "script")),
-  credential: import_effect2.Schema.optional(import_effect2.Schema.String),
-  stakePool: import_effect2.Schema.optional(import_effect2.Schema.NullOr(import_effect2.Schema.Struct({ id: import_effect2.Schema.String }))),
+var RewardAccountSummarySchema = S.Struct({
+  from: S.optional(S.Literal("key", "verificationKey", "script")),
+  credential: S.optional(S.String),
+  stakePool: S.optional(S.NullOr(S.Struct({ id: S.String }))),
   rewards: RewardAccountAdaSchema,
   deposit: RewardAccountAdaSchema
 });
-var Delegation = import_effect2.Schema.Union(
-  import_effect2.Schema.Null,
-  import_effect2.Schema.Record({
-    key: import_effect2.Schema.String,
+var Delegation = S.Union(
+  S.Null,
+  S.Record({
+    key: S.String,
     value: LegacyDelegationSummarySchema
   }),
-  import_effect2.Schema.Array(RewardAccountSummarySchema)
+  S.Array(RewardAccountSummarySchema)
 );
 var toOgmiosQuantity = (amount) => {
   const quantity = Number(amount);
@@ -812,9 +819,9 @@ var toOgmiosQuantity = (amount) => {
   }
   return quantity;
 };
-var RedeemerSchema = import_effect2.Schema.Struct({
-  validator: import_effect2.Schema.Struct({
-    purpose: import_effect2.Schema.Literal(
+var RedeemerSchema = S.Struct({
+  validator: S.Struct({
+    purpose: S.Literal(
       "spend",
       "mint",
       "publish",
@@ -822,11 +829,11 @@ var RedeemerSchema = import_effect2.Schema.Struct({
       "vote",
       "propose"
     ),
-    index: import_effect2.Schema.Int
+    index: S.Int
   }),
-  budget: import_effect2.Schema.Struct({
-    memory: import_effect2.Schema.Int,
-    cpu: import_effect2.Schema.Int
+  budget: S.Struct({
+    memory: S.Int,
+    cpu: S.Int
   })
 }).annotations({ identifier: "RedeemerSchema" });
 var toOgmiosUTxOs = (utxos) => {
@@ -884,62 +891,66 @@ var toOgmiosUTxOs = (utxos) => {
 };
 
 // src/internal/kupo.ts
-var import_effect3 = require("effect");
-var QuantitySchema = import_effect3.Schema.Union(
-  import_effect3.Schema.Number.pipe(import_effect3.Schema.filter(Number.isSafeInteger)),
-  import_effect3.Schema.String.pipe(import_effect3.Schema.pattern(/^\d+$/))
+var S2 = __toESM(require("effect/Schema"), 1);
+var QuantitySchema = S2.Union(
+  S2.Number.pipe(S2.filter(Number.isSafeInteger)),
+  S2.String.pipe(S2.pattern(/^\d+$/))
 );
-var ValueSchema = import_effect3.Schema.Struct({
+var ValueSchema = S2.Struct({
   coins: QuantitySchema,
-  assets: import_effect3.Schema.Record({ key: import_effect3.Schema.String, value: QuantitySchema })
+  assets: S2.Record({ key: S2.String, value: QuantitySchema })
 });
-var PointSchema = import_effect3.Schema.Struct({
-  slot_no: import_effect3.Schema.Number,
-  header_hash: import_effect3.Schema.String
+var PointSchema = S2.Struct({
+  slot_no: S2.Number,
+  header_hash: 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 ScriptSchema = S2.NullOr(
+  S2.Struct({
+    language: S2.Literal("native", "plutus:v1", "plutus:v2", "plutus:v3"),
+    script: S2.String
   })
 );
 var UTxOFields = {
-  transaction_index: import_effect3.Schema.Number,
-  transaction_id: import_effect3.Schema.String,
-  output_index: import_effect3.Schema.Number,
-  address: import_effect3.Schema.String,
+  transaction_index: S2.Number,
+  transaction_id: S2.String,
+  output_index: S2.Number,
+  address: S2.String,
   value: ValueSchema,
-  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),
+  datum_hash: S2.NullOr(S2.String),
+  datum_type: S2.optional(S2.Literal("hash", "inline")),
+  script_hash: S2.NullOr(S2.String),
   created_at: PointSchema,
-  spent_at: import_effect3.Schema.NullOr(PointSchema)
+  spent_at: S2.NullOr(PointSchema)
 };
-var UTxOSchema = import_effect3.Schema.Struct(UTxOFields);
-var ResolvedUTxOSchema = import_effect3.Schema.Struct({
+var UTxOSchema = S2.Struct(UTxOFields);
+var ResolvedUTxOSchema = S2.Struct({
   ...UTxOFields,
-  datum: import_effect3.Schema.NullOr(import_effect3.Schema.String),
+  datum: S2.NullOr(S2.String),
   script: ScriptSchema
 });
-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 }) })
+var DatumSchema = S2.NullOr(S2.Struct({ datum: S2.String }));
+var DelegationSchema = S2.NullOr(
+  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
-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({
+var HttpClient = __toESM(require("@effect/platform/HttpClient"), 1);
+var HttpClientError = __toESM(require("@effect/platform/HttpClientError"), 1);
+var HttpClientRequest = __toESM(require("@effect/platform/HttpClientRequest"), 1);
+var HttpClientResponse = __toESM(require("@effect/platform/HttpClientResponse"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var import_Function2 = require("effect/Function");
+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",
@@ -948,56 +959,51 @@ var filterStatusOk = (self) => self.status >= 200 && self.status < 300 ? import_
     )
   )
 );
-var makeGet = (url, schema, headers) => (0, import_effect4.pipe)(
+var makeGet = (url, schema, headers) => (0, import_Function2.pipe)(
   // Initiate a GET request to the specified URL
-  import_platform.HttpClientRequest.get(url),
+  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,
+  headers ? HttpClientRequest.setHeaders(headers) : import_Function2.identity,
+  HttpClient.execute,
   // Ensure only 2xx responses are treated as successes.
-  import_effect4.Effect.flatMap(filterStatusOk),
+  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
+  Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)),
+  Effect.scoped
 );
-var makePostAsJson = (url, data, schema, headers) => (0, import_effect4.pipe)(
+var makePostAsJson = (url, data, schema, headers) => (0, import_Function2.pipe)(
   // Initiate a POST request to the specified URL
-  import_platform.HttpClientRequest.post(url),
+  HttpClientRequest.post(url),
   // Conditional headers
-  headers ? import_platform.HttpClientRequest.setHeaders(headers) : import_effect4.identity,
+  headers ? HttpClientRequest.setHeaders(headers) : import_Function2.identity,
   // Set the request body as Json
-  import_platform.HttpClientRequest.bodyJson(data),
+  HttpClientRequest.bodyJson(data),
   // Execute the HTTP request and retrieve the response
-  import_effect4.Effect.flatMap(import_platform.HttpClient.execute),
+  Effect.flatMap(HttpClient.execute),
   // Ensure only 2xx responses are treated as successes.
-  import_effect4.Effect.flatMap(filterStatusOk),
+  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
+  Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)),
+  Effect.scoped
 );
-var makePostAsJsonResponse = (url, data, schema, headers) => (0, import_effect4.pipe)(
-  import_platform.HttpClientRequest.post(url),
-  headers ? import_platform.HttpClientRequest.setHeaders(headers) : import_effect4.identity,
-  import_platform.HttpClientRequest.bodyJson(data),
-  import_effect4.Effect.flatMap(import_platform.HttpClient.execute),
-  import_effect4.Effect.flatMap(
-    (response) => (0, import_effect4.pipe)(
-      import_platform.HttpClientResponse.schemaBodyJson(schema)(response),
-      import_effect4.Effect.map((body) => ({
+var makePostAsJsonResponse = (url, data, schema, headers) => (0, import_Function2.pipe)(
+  HttpClientRequest.post(url),
+  headers ? HttpClientRequest.setHeaders(headers) : import_Function2.identity,
+  HttpClientRequest.bodyJson(data),
+  Effect.flatMap(HttpClient.execute),
+  Effect.flatMap(
+    (response) => (0, import_Function2.pipe)(
+      HttpClientResponse.schemaBodyJson(schema)(response),
+      Effect.map((body) => ({
         body,
         status: response.status,
         headers: response.headers
       })),
-      import_effect4.Effect.catchAll(
-        (cause) => response.status >= 200 && response.status < 300 ? import_effect4.Effect.fail(cause) : import_effect4.Effect.fail(
-          new import_platform.HttpClientError.ResponseError({
+      Effect.catchAll(
+        (cause) => response.status >= 200 && response.status < 300 ? Effect.fail(cause) : Effect.fail(
+          new HttpClientError.ResponseError({
             response,
             request: response.request,
             reason: "StatusCode",
@@ -1007,54 +1013,51 @@ var makePostAsJsonResponse = (url, data, schema, headers) => (0, import_effect4.
       )
     )
   ),
-  import_effect4.Effect.scoped
+  Effect.scoped
 );
-var makePostAsUint8Array = (url, data, schema, headers) => (0, import_effect4.pipe)(
+var makePostAsUint8Array = (url, data, schema, headers) => (0, import_Function2.pipe)(
   // Initiate a POST request to the specified URL
-  import_platform.HttpClientRequest.post(url),
+  HttpClientRequest.post(url),
   // Conditional bearer token authentication
-  headers ? import_platform.HttpClientRequest.setHeaders(headers) : import_effect4.identity,
+  headers ? HttpClientRequest.setHeaders(headers) : import_Function2.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,
+  HttpClientRequest.bodyUint8Array(data, "application/cbor"),
+  HttpClient.execute,
   // Ensure only 2xx responses are treated as successes.
-  import_effect4.Effect.flatMap(filterStatusOk),
+  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
+  Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)),
+  Effect.scoped
 );
 
 // src/kupmios.ts
-var import_platform2 = require("@effect/platform");
+var FetchHttpClient = __toESM(require("@effect/platform/FetchHttpClient"), 1);
 var DEFAULT_REQUEST_TIMEOUT_MS2 = 3e4;
 var DEFAULT_AWAIT_TX_TIMEOUT_MS = 16e4;
-var validateTimeout = (name, timeout) => {
-  if (!Number.isFinite(timeout) || timeout <= 0) {
+var validateTimeout = (name, timeout3) => {
+  if (!Number.isFinite(timeout3) || timeout3 <= 0) {
     throw new TypeError(`${name} must be a positive finite number.`);
   }
-  return timeout;
+  return timeout3;
 };
-var catchProviderError = (protocol, operation) => (effect) => import_effect6.Effect.catchAll(
+var catchProviderError = (protocol, operation) => (effect) => Effect2.catchAll(
   effect,
-  (cause) => import_effect6.Effect.fail(toKupmiosError(cause, protocol, operation))
+  (cause) => Effect2.fail(toKupmiosError(cause, protocol, operation))
 );
 var runProviderEffect = async (effect, protocol, operation, signal) => {
-  const exit = await import_effect6.Effect.runPromiseExit(effect, { signal });
-  if (import_effect6.Exit.isSuccess(exit)) return exit.value;
+  const exit = await Effect2.runPromiseExit(effect, { signal });
+  if (Exit.isSuccess(exit)) return exit.value;
   if (signal?.aborted) {
     throw new KupmiosError({
       protocol,
       operation,
       kind: "aborted",
       retryable: false,
-      cause: signal.reason ?? import_effect6.Cause.squash(exit.cause)
+      cause: signal.reason ?? Cause.squash(exit.cause)
     });
   }
-  throw toKupmiosError(import_effect6.Cause.squash(exit.cause), protocol, operation);
+  throw toKupmiosError(Cause.squash(exit.cause), protocol, operation);
 };
 var Kupmios = class {
   kupoUrl;
@@ -1075,9 +1078,9 @@ var Kupmios = class {
       "awaitTxTimeoutMs",
       options.awaitTxTimeoutMs ?? DEFAULT_AWAIT_TX_TIMEOUT_MS
     );
-    this.httpLayer = options.fetchImpl === void 0 ? import_platform2.FetchHttpClient.layer : import_effect6.Layer.provide(
-      import_platform2.FetchHttpClient.layer,
-      import_effect6.Layer.succeed(import_platform2.FetchHttpClient.Fetch, options.fetchImpl)
+    this.httpLayer = options.fetchImpl === void 0 ? FetchHttpClient.layer : Layer.provide(
+      FetchHttpClient.layer,
+      Layer.succeed(FetchHttpClient.Fetch, options.fetchImpl)
     );
   }
   async getProtocolParameters() {
@@ -1088,19 +1091,19 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCResponseSchema(
-      import_effect5.Schema.Record({ key: import_effect5.Schema.String, value: import_effect5.Schema.Unknown })
+      S3.Record({ key: S3.String, value: S3.Unknown })
     );
     const response = await runProviderEffect(
-      (0, import_effect6.pipe)(
+      (0, import_Function3.pipe)(
         makePostAsJsonResponse(
           this.ogmiosUrl,
           data,
           schema,
           this.options.ogmiosHeader
         ),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
+        Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "queryLedgerState/protocolParameters"),
-        import_effect6.Effect.provide(this.httpLayer)
+        Effect2.provide(this.httpLayer)
       ),
       "ogmios",
       "queryLedgerState/protocolParameters"
@@ -1110,7 +1113,7 @@ var Kupmios = class {
       data.method,
       response
     );
-    const protocolParameters = import_effect5.Schema.decodeUnknownSync(
+    const protocolParameters = S3.decodeUnknownSync(
       ProtocolParametersSchema
     )(normalizeProtocolParameters(result));
     return toProtocolParameters(protocolParameters);
@@ -1126,16 +1129,16 @@ var Kupmios = class {
       TreasuryAndReservesSchema
     );
     const response = await runProviderEffect(
-      (0, import_effect6.pipe)(
+      (0, import_Function3.pipe)(
         makePostAsJsonResponse(
           this.ogmiosUrl,
           data,
           schema,
           this.options.ogmiosHeader
         ),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
+        Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "queryLedgerState/treasuryAndReserves"),
-        import_effect6.Effect.provide(this.httpLayer)
+        Effect2.provide(this.httpLayer)
       ),
       "ogmios",
       "queryLedgerState/treasuryAndReserves"
@@ -1150,15 +1153,15 @@ var Kupmios = class {
   async getUtxos(addressOrCredential) {
     const isAddress = typeof addressOrCredential === "string";
     const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
-    const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&resolve_hashes`;
-    const schema = import_effect5.Schema.Array(ResolvedUTxOSchema);
+    const pattern2 = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&resolve_hashes`;
+    const schema = S3.Array(ResolvedUTxOSchema);
     const utxos = await runProviderEffect(
-      (0, import_effect6.pipe)(
-        makeGet(pattern, schema, this.options.kupoHeader),
-        import_effect6.Effect.map(kupmiosUtxosToUtxos),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
+      (0, import_Function3.pipe)(
+        makeGet(pattern2, schema, this.options.kupoHeader),
+        Effect2.map(kupmiosUtxosToUtxos),
+        Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxos"),
-        import_effect6.Effect.provide(this.httpLayer)
+        Effect2.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxos"
@@ -1169,15 +1172,15 @@ var Kupmios = class {
     const isAddress = typeof addressOrCredential === "string";
     const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
     const { policyId, assetName } = (0, import_utils4.fromUnit)(unit);
-    const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&resolve_hashes&policy_id=${policyId}${assetName ? `&asset_name=${assetName}` : ""}`;
-    const schema = import_effect5.Schema.Array(ResolvedUTxOSchema);
+    const pattern2 = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&resolve_hashes&policy_id=${policyId}${assetName ? `&asset_name=${assetName}` : ""}`;
+    const schema = S3.Array(ResolvedUTxOSchema);
     const utxos = await runProviderEffect(
-      (0, import_effect6.pipe)(
-        makeGet(pattern, schema, this.options.kupoHeader),
-        import_effect6.Effect.map(kupmiosUtxosToUtxos),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
+      (0, import_Function3.pipe)(
+        makeGet(pattern2, schema, this.options.kupoHeader),
+        Effect2.map(kupmiosUtxosToUtxos),
+        Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxosWithUnit"),
-        import_effect6.Effect.provide(this.httpLayer)
+        Effect2.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxosWithUnit"
@@ -1193,15 +1196,15 @@ var Kupmios = class {
     const normalizedPolicyId = policyId.toLowerCase();
     const isAddress = typeof addressOrCredential === "string";
     const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
-    const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&resolve_hashes&policy_id=${normalizedPolicyId}`;
-    const schema = import_effect5.Schema.Array(ResolvedUTxOSchema);
+    const pattern2 = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&resolve_hashes&policy_id=${normalizedPolicyId}`;
+    const schema = S3.Array(ResolvedUTxOSchema);
     return runProviderEffect(
-      (0, import_effect6.pipe)(
-        makeGet(pattern, schema, this.options.kupoHeader),
-        import_effect6.Effect.map(kupmiosUtxosToUtxos),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
+      (0, import_Function3.pipe)(
+        makeGet(pattern2, schema, this.options.kupoHeader),
+        Effect2.map(kupmiosUtxosToUtxos),
+        Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxosWithPolicy"),
-        import_effect6.Effect.provide(this.httpLayer)
+        Effect2.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxosWithPolicy"
@@ -1209,15 +1212,15 @@ var Kupmios = class {
   }
   async getUtxoByUnit(unit) {
     const { policyId, assetName } = (0, import_utils4.fromUnit)(unit);
-    const pattern = `${this.kupoUrl}/matches/${policyId}.${assetName ?? ""}?unspent&resolve_hashes`;
-    const schema = import_effect5.Schema.Array(ResolvedUTxOSchema);
+    const pattern2 = `${this.kupoUrl}/matches/${policyId}.${assetName ?? ""}?unspent&resolve_hashes`;
+    const schema = S3.Array(ResolvedUTxOSchema);
     const utxos = await runProviderEffect(
-      (0, import_effect6.pipe)(
-        makeGet(pattern, schema, this.options.kupoHeader),
-        import_effect6.Effect.map(kupmiosUtxosToUtxos),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
+      (0, import_Function3.pipe)(
+        makeGet(pattern2, schema, this.options.kupoHeader),
+        Effect2.map(kupmiosUtxosToUtxos),
+        Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxoByUnit"),
-        import_effect6.Effect.provide(this.httpLayer)
+        Effect2.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxoByUnit"
@@ -1235,22 +1238,22 @@ var Kupmios = class {
       ...new Set(outRefs.map((outRef) => outRef.txHash))
     ];
     const mkPattern = (txHash) => `${this.kupoUrl}/matches/*@${txHash}?unspent&resolve_hashes`;
-    const schema = import_effect5.Schema.Array(ResolvedUTxOSchema);
-    const program = import_effect6.Effect.forEach(
+    const schema = S3.Array(ResolvedUTxOSchema);
+    const program = Effect2.forEach(
       queryHashes,
-      (txHash) => (0, import_effect6.pipe)(
+      (txHash) => (0, import_Function3.pipe)(
         makeGet(mkPattern(txHash), schema, this.options.kupoHeader),
-        import_effect6.Effect.map(kupmiosUtxosToUtxos),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
+        Effect2.map(kupmiosUtxosToUtxos),
+        Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxosByOutRef")
       )
     );
     const utxos = await runProviderEffect(
-      (0, import_effect6.pipe)(program, import_effect6.Effect.provide(this.httpLayer)),
+      (0, import_Function3.pipe)(program, Effect2.provide(this.httpLayer)),
       "kupo",
       "getUtxosByOutRef"
     );
-    return import_effect6.Array.flatten(utxos).filter(
+    return _Array.flatten(utxos).filter(
       (utxo) => outRefs.some(
         (outRef) => utxo.txHash === outRef.txHash && utxo.outputIndex === outRef.outputIndex
       )
@@ -1265,15 +1268,15 @@ var Kupmios = class {
     };
     const schema = JSONRPCResponseSchema(Delegation);
     const response = await runProviderEffect(
-      (0, import_effect6.pipe)(
+      (0, import_Function3.pipe)(
         makePostAsJsonResponse(
           this.ogmiosUrl,
           data,
           schema,
           this.options.ogmiosHeader
         ),
-        import_effect6.Effect.provide(this.httpLayer),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
+        Effect2.provide(this.httpLayer),
+        Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "queryLedgerState/rewardAccountSummaries")
       ),
       "ogmios",
@@ -1291,14 +1294,14 @@ var Kupmios = class {
     return { poolId, rewards };
   }
   async getDatum(datumHash) {
-    const pattern = `${this.kupoUrl}/datums/${datumHash}`;
+    const pattern2 = `${this.kupoUrl}/datums/${datumHash}`;
     const schema = DatumSchema;
     const result = await runProviderEffect(
-      (0, import_effect6.pipe)(
-        makeGet(pattern, schema, this.options.kupoHeader),
-        import_effect6.Effect.provide(this.httpLayer),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
-        import_effect6.Effect.flatMap(import_effect6.Effect.fromNullable),
+      (0, import_Function3.pipe)(
+        makeGet(pattern2, schema, this.options.kupoHeader),
+        Effect2.provide(this.httpLayer),
+        Effect2.timeout(this.requestTimeoutMs),
+        Effect2.flatMap(Effect2.fromNullable),
         catchProviderError("kupo", "getDatum")
       ),
       "kupo",
@@ -1307,16 +1310,16 @@ var Kupmios = class {
     return result.datum;
   }
   async getTransactionStatus(txHash, options = {}) {
-    const pattern = `${this.kupoUrl}/matches/*@${txHash}`;
-    const schema = import_effect5.Schema.Array(UTxOSchema).annotations({
+    const pattern2 = `${this.kupoUrl}/matches/*@${txHash}`;
+    const schema = S3.Array(UTxOSchema).annotations({
       identifier: "Array<KupmiosSchema.KupoUTxO>"
     });
     const matches = await runProviderEffect(
-      (0, import_effect6.pipe)(
-        makeGet(pattern, schema, this.options.kupoHeader),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
+      (0, import_Function3.pipe)(
+        makeGet(pattern2, schema, this.options.kupoHeader),
+        Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getTransactionStatus"),
-        import_effect6.Effect.provide(this.httpLayer)
+        Effect2.provide(this.httpLayer)
       ),
       "kupo",
       "getTransactionStatus",
@@ -1335,21 +1338,21 @@ var Kupmios = class {
     };
   }
   async awaitTx(txHash, checkInterval = 2e4) {
-    const pattern = `${this.kupoUrl}/matches/*@${txHash}`;
-    const schema = import_effect5.Schema.Array(UTxOSchema).annotations({
+    const pattern2 = `${this.kupoUrl}/matches/*@${txHash}`;
+    const schema = S3.Array(UTxOSchema).annotations({
       identifier: "Array<KupmiosSchema.KupoUTxO>"
     });
     const result = await runProviderEffect(
-      (0, import_effect6.pipe)(
-        makeGet(pattern, schema, this.options.kupoHeader),
-        import_effect6.Effect.provide(this.httpLayer),
-        import_effect6.Effect.repeat({
-          schedule: import_effect6.Schedule.exponential(checkInterval),
+      (0, import_Function3.pipe)(
+        makeGet(pattern2, schema, this.options.kupoHeader),
+        Effect2.provide(this.httpLayer),
+        Effect2.repeat({
+          schedule: Schedule.exponential(checkInterval),
           until: (result2) => result2.length > 0
         }),
-        import_effect6.Effect.timeout(this.awaitTxTimeoutMs),
+        Effect2.timeout(this.awaitTxTimeoutMs),
         catchProviderError("kupo", "awaitTx"),
-        import_effect6.Effect.as(true)
+        Effect2.as(true)
       ),
       "kupo",
       "awaitTx"
@@ -1366,22 +1369,22 @@ var Kupmios = class {
       id: null
     };
     const schema = JSONRPCResponseSchema(
-      import_effect5.Schema.Struct({
-        transaction: import_effect5.Schema.Struct({
-          id: import_effect5.Schema.String
+      S3.Struct({
+        transaction: S3.Struct({
+          id: S3.String
         })
       })
     );
     const response = await runProviderEffect(
-      (0, import_effect6.pipe)(
+      (0, import_Function3.pipe)(
         makePostAsJsonResponse(
           this.ogmiosUrl,
           data,
           schema,
           this.options.ogmiosHeader
         ),
-        import_effect6.Effect.provide(this.httpLayer),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
+        Effect2.provide(this.httpLayer),
+        Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "submitTransaction")
       ),
       "ogmios",
@@ -1404,17 +1407,17 @@ var Kupmios = class {
       },
       id: null
     };
-    const schema = JSONRPCResponseSchema(import_effect5.Schema.Array(RedeemerSchema));
+    const schema = JSONRPCResponseSchema(S3.Array(RedeemerSchema));
     const response = await runProviderEffect(
-      (0, import_effect6.pipe)(
+      (0, import_Function3.pipe)(
         makePostAsJsonResponse(
           this.ogmiosUrl,
           data,
           schema,
           this.options.ogmiosHeader
         ),
-        import_effect6.Effect.provide(this.httpLayer),
-        import_effect6.Effect.timeout(this.requestTimeoutMs),
+        Effect2.provide(this.httpLayer),
+        Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "evaluateTransaction")
       ),
       "ogmios",
@@ -1524,6 +1527,53 @@ var import_utils7 = require("@lucid-evolution/utils");
 var import_core_utils2 = require("@lucid-evolution/core-utils");
 var import_wallet = require("@lucid-evolution/wallet");
 
+// src/internal/ed25519.ts
+var nodeCrypto = (() => {
+  try {
+    return globalThis.process?.getBuiltinModule?.("node:crypto");
+  } catch {
+    return void 0;
+  }
+})();
+var SPKI_PREFIX = [
+  48,
+  42,
+  48,
+  5,
+  6,
+  3,
+  43,
+  101,
+  112,
+  3,
+  33,
+  0
+];
+var nativeVerifyEd25519 = (publicKey, message, signature) => {
+  if (!nodeCrypto || publicKey.length !== 32 || signature.length !== 64) {
+    return false;
+  }
+  if (publicKey.every((byte) => byte === 0)) return false;
+  try {
+    const spki = Buffer.alloc(SPKI_PREFIX.length + 32);
+    spki.set(SPKI_PREFIX);
+    spki.set(publicKey, SPKI_PREFIX.length);
+    const key = nodeCrypto.createPublicKey({
+      key: spki,
+      format: "der",
+      type: "spki"
+    });
+    return nodeCrypto.verify(null, message, key, signature);
+  } catch {
+    return false;
+  }
+};
+var verifyEd25519 = (publicKey, message, signature) => nativeVerifyEd25519(
+  publicKey.to_raw_bytes(),
+  message,
+  signature.to_raw_bytes()
+) || publicKey.verify(message, signature);
+
 // src/internal/emulator-ledger.ts
 var import_utils5 = require("@lucid-evolution/utils");
 var isUnorderedKey = (key) => {
@@ -2035,7 +2085,11 @@ var Emulator = class {
           const witness = own3(vkeyWitnesses.get(i));
           const publicKey = own3(witness.vkey());
           const keyHash = own3(publicKey.hash()).to_hex();
-          if (!publicKey.verify((0, import_core_utils2.fromHex)(txHash), own3(witness.ed25519_signature()))) {
+          if (!verifyEd25519(
+            publicKey,
+            (0, import_core_utils2.fromHex)(txHash),
+            own3(witness.ed25519_signature())
+          )) {
             throw new Error(`Invalid vkey witness. Key hash: ${keyHash}`);
           }
           keyHashes2.push(keyHash);
@@ -2876,210 +2930,212 @@ var import_core_utils3 = require("@lucid-evolution/core-utils");
 var import_utils9 = require("@lucid-evolution/utils");
 
 // src/internal/koios.ts
-var import_platform3 = require("@effect/platform");
-var import_effect7 = require("effect");
+var FetchHttpClient2 = __toESM(require("@effect/platform/FetchHttpClient"), 1);
+var Effect3 = __toESM(require("effect/Effect"), 1);
+var S4 = __toESM(require("effect/Schema"), 1);
+var import_Function4 = require("effect/Function");
 var import_utils8 = require("@lucid-evolution/utils");
-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)
+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)
   }),
-  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
+  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
 });
-var TotalsSchema = import_effect7.Schema.Struct({
-  treasury: import_effect7.Schema.String
+var TotalsSchema = S4.Struct({
+  treasury: 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 AssetSchema = S4.Struct({
+  policy_id: S4.String,
+  asset_name: S4.NullOr(S4.String),
+  fingerprint: S4.String,
+  decimals: S4.Number,
+  quantity: S4.String
 });
-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 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 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
+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
     })
   ),
-  reference_script: import_effect7.Schema.NullOr(ReferenceScriptSchema),
-  asset_list: import_effect7.Schema.NullOr(import_effect7.Schema.Array(AssetSchema))
+  reference_script: S4.NullOr(ReferenceScriptSchema),
+  asset_list: S4.NullOr(S4.Array(AssetSchema))
 });
-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 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 InputOutputSchema = import_effect7.Schema.Struct({
-  payment_addr: import_effect7.Schema.Struct({
-    bech32: import_effect7.Schema.String,
-    cred: import_effect7.Schema.String
+var InputOutputSchema = S4.Struct({
+  payment_addr: S4.Struct({
+    bech32: S4.String,
+    cred: S4.String
   }),
-  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
+  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
     })
   ),
-  reference_script: import_effect7.Schema.NullOr(ReferenceScriptSchema),
-  asset_list: import_effect7.Schema.Array(AssetSchema)
+  reference_script: S4.NullOr(ReferenceScriptSchema),
+  asset_list: S4.Array(AssetSchema)
 });
-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
+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
       })
     )
   ),
-  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)
+  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)
       })
     )
   ),
-  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
+  native_scripts: S4.NullOr(
+    S4.Array(
+      S4.Struct({
+        script_hash: S4.String,
+        script_json: S4.Object
       })
     )
   ),
-  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
+  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
           })
         ),
-        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
+        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
             }),
-            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)
+          datum: S4.Struct({
+            hash: S4.NullOr(S4.String),
+            value: S4.NullOr(S4.Object)
           })
         })
       })
@@ -3087,28 +3143,28 @@ var TxInfoSchema = import_effect7.Schema.Struct({
   ),
   //TODO: add S.Struct
   // https://preprod.koios.rest/#post-/tx_info
-  voting_procedures: import_effect7.Schema.Array(import_effect7.Schema.Object),
+  voting_procedures: S4.Array(S4.Object),
   //TODO: add S.Struct
   // https://preprod.koios.rest/#post-/tx_info
-  proposal_procedures: import_effect7.Schema.Object
+  proposal_procedures: S4.Object
 });
-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 TxHashSchema = S4.String;
+var AssetAddressSchema = S4.Struct({
+  payment_address: S4.String,
+  stake_address: S4.NullOr(S4.String),
+  quantity: S4.String
 });
-var AccountInfoSchema = import_effect7.Schema.Struct({
-  status: import_effect7.Schema.Literal("registered", "not registered"),
-  delegated_pool: import_effect7.Schema.NullOr(import_effect7.Schema.String),
-  rewards_available: import_effect7.Schema.String
+var AccountInfoSchema = S4.Struct({
+  status: S4.Literal("registered", "not registered"),
+  delegated_pool: S4.NullOr(S4.String),
+  rewards_available: S4.String
 });
-var TxStatusSchema = import_effect7.Schema.Struct({
-  tx_hash: import_effect7.Schema.String,
-  num_confirmations: import_effect7.Schema.NullOr(import_effect7.Schema.Number)
+var TxStatusSchema = S4.Struct({
+  tx_hash: S4.String,
+  num_confirmations: S4.NullOr(S4.Number)
 });
-var DatumInfo = import_effect7.Schema.Struct({
-  bytes: import_effect7.Schema.String
+var DatumInfo = S4.Struct({
+  bytes: S4.String
 });
 var toUTxO = (koiosUTxO, address) => ({
   txHash: koiosUTxO.tx_hash,
@@ -3157,23 +3213,27 @@ var getUtxosEffect = (baseUrl, addressOrCredential, headers) => {
     _addresses: [addressOrCredential]
   };
   const schema = AddressInfoSchema;
-  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."),
+  const result = (0, import_Function4.pipe)(
+    Effect3.if(typeof addressOrCredential === "string", {
+      onFalse: () => Effect3.fail("Credential Type is not supported in Koios yet."),
       onTrue: () => makePostAsJson(url, body, schema, headers)
     }),
-    import_effect7.Effect.map(
+    Effect3.map(
       ([result2]) => result2 ? result2.utxo_set.map((koiosUtxo) => toUTxO(koiosUtxo, result2.address)) : []
     ),
-    import_effect7.Effect.provide(import_platform3.FetchHttpClient.layer)
+    Effect3.provide(FetchHttpClient2.layer)
   );
   return result;
 };
 
 // src/koios.ts
-var import_effect8 = require("effect");
-var import_platform4 = require("@effect/platform");
-var KoiosError = class extends import_effect8.Data.TaggedError("KoiosError") {
+var Data = __toESM(require("effect/Data"), 1);
+var Effect4 = __toESM(require("effect/Effect"), 1);
+var Schedule2 = __toESM(require("effect/Schedule"), 1);
+var S5 = __toESM(require("effect/Schema"), 1);
+var import_Function5 = require("effect/Function");
+var FetchHttpClient3 = __toESM(require("@effect/platform/FetchHttpClient"), 1);
+var KoiosError = class extends Data.TaggedError("KoiosError") {
   get message() {
     return `${this.cause}`;
   }
@@ -3187,15 +3247,15 @@ var Koios = class {
   }
   async getProtocolParameters() {
     const url = `${this.baseUrl}/epoch_params?limit=1`;
-    const schema = import_effect8.Schema.Array(ProtocolParametersSchema2);
+    const schema = S5.Array(ProtocolParametersSchema2);
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
-    const [result] = await (0, import_effect8.pipe)(
+    const [result] = await (0, import_Function5.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
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return {
       protocolMajorVersion: result.protocol_major,
@@ -3225,43 +3285,43 @@ var Koios = class {
   }
   async getTreasury() {
     const url = `${this.baseUrl}/totals?order=epoch_no.desc&limit=1`;
-    const schema = import_effect8.Schema.Array(TotalsSchema);
+    const schema = S5.Array(TotalsSchema);
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
-    const [result] = await (0, import_effect8.pipe)(
+    const [result] = await (0, import_Function5.pipe)(
       makeGet(url, schema, bearerToken),
-      import_effect8.Effect.provide(import_platform4.FetchHttpClient.layer),
-      import_effect8.Effect.flatMap(
-        (result2) => result2.length === 0 ? import_effect8.Effect.fail("No totals found") : import_effect8.Effect.succeed(result2)
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.flatMap(
+        (result2) => result2.length === 0 ? Effect4.fail("No totals found") : Effect4.succeed(result2)
       ),
-      import_effect8.Effect.timeout(1e4),
-      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect8.Effect.runPromise
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return BigInt(result.treasury);
   }
   async getUtxos(addressOrCredential) {
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
-    const result = await (0, import_effect8.pipe)(
+    const result = await (0, import_Function5.pipe)(
       getUtxosEffect(this.baseUrl, addressOrCredential, bearerToken),
-      import_effect8.Effect.timeout(1e4),
-      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect8.Effect.runPromise
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return result;
   }
   async getUtxosWithUnit(addressOrCredential, unit) {
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
-    const result = await (0, import_effect8.pipe)(
+    const result = await (0, import_Function5.pipe)(
       getUtxosEffect(this.baseUrl, addressOrCredential, bearerToken),
-      import_effect8.Effect.map(
+      Effect4.map(
         (utxos) => utxos.filter((utxo) => {
           const keys = Object.keys(utxo.assets);
           return keys.length > 0 && keys.includes(unit);
         })
       ),
-      import_effect8.Effect.timeout(1e4),
-      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect8.Effect.runPromise
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return result;
   }
@@ -3269,35 +3329,35 @@ var Koios = class {
     let { policyId, assetName } = (0, import_utils9.fromUnit)(unit);
     const url = `${this.baseUrl}/asset_addresses?_asset_policy=${policyId}&_asset_name=${assetName}`;
     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),
+    const result = await (0, import_Function5.pipe)(
+      makeGet(url, S5.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)
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.flatMap(
+        (adresses) => adresses.length === 0 ? Effect4.fail("Unit not found") : Effect4.succeed(adresses)
       ),
-      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])
+      Effect4.flatMap(
+        (adresses) => adresses.length > 1 ? Effect4.fail("Unit needs to be an NFT or only held by one address.") : Effect4.succeed(adresses[0])
       ),
-      import_effect8.Effect.flatMap(
+      Effect4.flatMap(
         (address) => getUtxosEffect(
           this.baseUrl,
           address.payment_address,
           bearerToken
         )
       ),
-      import_effect8.Effect.map(
+      Effect4.map(
         (utxos) => utxos.filter((utxo) => {
           const keys = Object.keys(utxo.assets);
           return keys.length > 0 && keys.includes(unit);
         })
       ),
-      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])
+      Effect4.flatMap(
+        (utxos) => utxos.length > 1 ? Effect4.fail("Unit needs to be an NFT or only held by one address.") : Effect4.succeed(utxos[0])
       ),
-      import_effect8.Effect.timeout(1e4),
-      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect8.Effect.runPromise
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return result;
   }
@@ -3308,15 +3368,15 @@ var Koios = class {
       _assets: true,
       _scripts: true
     };
-    const schema = import_effect8.Schema.Array(TxInfoSchema);
+    const schema = S5.Array(TxInfoSchema);
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
-    const [result] = await (0, import_effect8.pipe)(
+    const [result] = await (0, import_Function5.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
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     if (result) {
       const utxos = result.outputs.map(
@@ -3350,18 +3410,18 @@ var Koios = class {
     };
     const url = `${this.baseUrl}/account_info`;
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
-    const result = await (0, import_effect8.pipe)(
+    const result = await (0, import_Function5.pipe)(
       makePostAsJson(
         url,
         body,
-        import_effect8.Schema.Array(AccountInfoSchema),
+        S5.Array(AccountInfoSchema),
         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
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     const account = result[0];
     if (!account) {
@@ -3383,21 +3443,21 @@ var Koios = class {
       _datum_hashes: [datumHash]
     };
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
-    const result = await (0, import_effect8.pipe)(
+    const result = await (0, import_Function5.pipe)(
       makePostAsJson(
         url,
         body,
-        import_effect8.Schema.Array(DatumInfo),
+        S5.Array(DatumInfo),
         bearerToken
       ),
       // 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])
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.flatMap(
+        (result2) => result2.length === 0 ? Effect4.fail("No Datum Found by Datum Hash") : Effect4.succeed(result2[0])
       ),
-      import_effect8.Effect.timeout(1e4),
-      import_effect8.Effect.catchAllCause((cause) => new KoiosError({ cause })),
-      import_effect8.Effect.runPromise
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return result.bytes;
   }
@@ -3406,20 +3466,20 @@ var Koios = class {
     const body = {
       _tx_hashes: [txHash]
     };
-    const schema = import_effect8.Schema.Array(TxInfoSchema);
+    const schema = S5.Array(TxInfoSchema);
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
-    const result = await (0, import_effect8.pipe)(
+    const result = await (0, import_Function5.pipe)(
       makePostAsJson(url, body, schema, bearerToken),
-      import_effect8.Effect.repeat({
-        schedule: import_effect8.Schedule.exponential(checkInterval),
+      Effect4.repeat({
+        schedule: Schedule2.exponential(checkInterval),
         until: (result2) => result2.length > 0
       }),
       // 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
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.timeout(16e4),
+      Effect4.orDie,
+      Effect4.as(true),
+      Effect4.runPromise
     );
     return result;
   }
@@ -3439,7 +3499,7 @@ var Koios = class {
         `Could not fetch transaction status from Koios. Received status code: ${response.status}`
       );
     }
-    const result = import_effect8.Schema.decodeUnknownSync(import_effect8.Schema.Array(TxStatusSchema))(
+    const result = S5.decodeUnknownSync(S5.Array(TxStatusSchema))(
       await response.json()
     );
     const status = result[0];
@@ -3460,13 +3520,13 @@ var Koios = class {
     const body = (0, import_core_utils3.fromHex)(tx);
     const schema = TxHashSchema;
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
-    const result = await (0, import_effect8.pipe)(
+    const result = await (0, import_Function5.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
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     return result;
   }
@@ -3481,15 +3541,15 @@ var Koios = class {
       },
       id: null
     };
-    const schema = JSONRPCSchema(import_effect8.Schema.Array(RedeemerSchema));
+    const schema = JSONRPCSchema(S5.Array(RedeemerSchema));
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
-    const { result } = await (0, import_effect8.pipe)(
+    const { result } = await (0, import_Function5.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
+      Effect4.provide(FetchHttpClient3.layer),
+      Effect4.timeout(1e4),
+      Effect4.catchAllCause((cause) => new KoiosError({ cause })),
+      Effect4.runPromise
     );
     const evalRedeemers = result.map((item) => ({
       ex_units: {