@helios-lang/effect 0.1.11 → 0.1.13

package/types/Ledger/Address.d.ts

@@ -1,9 +1,9 @@
 import { Schema } from "effect";
 import * as Cbor from "../Cbor.js";
 import * as Bytes from "../internal/Bytes.js";
+import { IsMainnet } from "../Network/IsMainnet.js";
 import { Data } from "../Uplc/index.js";
 import * as Credential from "./Credential.js";
-import { IsMainnet } from "./IsMainnet.js";
 export declare function isValid(addr: string): boolean;
 export declare const Address: Schema.brand<Schema.filter<typeof Schema.String>, "Address">;
 export type Address = Schema.Schema.Type<typeof Address>;
@@ -78,11 +78,11 @@ export declare const FromUplcData: Schema.transformOrFail<Schema.transformOrFail
         readonly fields: readonly Data.Data[];
         readonly constructor: number;
     }, never>, Schema.Option<Schema.Schema<{
-        readonly _tag: "PubKey";
         readonly hash: string & import("effect/Brand").Brand<"PubKeyHash">;
+        readonly _tag: "PubKey";
     } | {
-        readonly _tag: "Validator";
         readonly hash: string & import("effect/Brand").Brand<"ValidatorHash">;
+        readonly _tag: "Validator";
     }, {
         readonly bytes: Uint8Array<ArrayBufferLike>;
     } | {

package/types/Ledger/Address.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Address.d.ts","sourceRoot":"","sources":["../../src/Ledger/Address.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE5D,OAAO,KAAK,IAAI,MAAM,YAAY,CAAA;AAClC,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAI1C,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAO7C;AAED,eAAO,MAAM,OAAO,8DAKnB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC,CAAA;AAExD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oFAiCxB,CAAA;AAED,wBAAgB,IAAI,CAClB,SAAS,EAAE,OAAO,EAClB,kBAAkB,EAAE,UAAU,CAAC,UAAU,EACzC,iBAAiB,CAAC,EAAE,UAAU,CAAC,UAAU,GACxC,OAAO,CAWT;AAkID,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAiBtE,CAAA;AAEH,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAEjD;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAEhD;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEnD;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CAAC,UAAU,CAE1E;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,GACf,UAAU,CAAC,UAAU,GAAG,SAAS,CAEnC"}
+{"version":3,"file":"Address.d.ts","sourceRoot":"","sources":["../../src/Ledger/Address.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE5D,OAAO,KAAK,IAAI,MAAM,YAAY,CAAA;AAClC,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAI7C,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAO7C;AAED,eAAO,MAAM,OAAO,8DAKnB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC,CAAA;AAExD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oFAiCxB,CAAA;AAED,wBAAgB,IAAI,CAClB,SAAS,EAAE,OAAO,EAClB,kBAAkB,EAAE,UAAU,CAAC,UAAU,EACzC,iBAAiB,CAAC,EAAE,UAAU,CAAC,UAAU,GACxC,OAAO,CAWT;AAkID,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAiBtE,CAAA;AAEH,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAEjD;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAEhD;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEnD;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CAAC,UAAU,CAE1E;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,GACf,UAAU,CAAC,UAAU,GAAG,SAAS,CAEnC"}

package/types/Ledger/AssetClass.d.ts

@@ -6,7 +6,7 @@ export declare function isValid(assetClass: string): assetClass is AssetClass;
 export declare const AssetClass: Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "AssetClass">>;
 export type AssetClass = Schema.Schema.Type<typeof AssetClass>;
 export declare const ADA: AssetClass;
-export declare function make(policy: MintingPolicy.MintingPolicy, tokenName: Bytes.BytesLike): string;
+export declare function make(policy: MintingPolicy.MintingPolicy, tokenName: Bytes.BytesLike): string & import("effect/Brand").Brand<"AssetClass">;
 export declare const FromUplcData: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
     readonly bytes: Uint8Array<ArrayBufferLike>;
 } | {

package/types/Ledger/AssetClass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetClass.d.ts","sourceRoot":"","sources":["../../src/Ledger/AssetClass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAGnD,wBAAgB,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,IAAI,UAAU,CAOpE;AAED,eAAO,MAAM,UAAU,yGAWtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9D,eAAO,MAAM,GAAG,EAAS,UAAU,CAAA;AAEnC,wBAAgB,IAAI,CAClB,MAAM,EAAE,aAAa,CAAC,aAAa,EACnC,SAAS,EAAE,KAAK,CAAC,SAAS,UAO3B;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oHAsBxB,CAAA;AAED,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,CAAC,aAAa,CAMtE;AAED,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAMpD"}
+{"version":3,"file":"AssetClass.d.ts","sourceRoot":"","sources":["../../src/Ledger/AssetClass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAGnD,wBAAgB,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,IAAI,UAAU,CAYpE;AAED,eAAO,MAAM,UAAU,yGAWtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9D,eAAO,MAAM,GAAG,EAAS,UAAU,CAAA;AAEnC,wBAAgB,IAAI,CAClB,MAAM,EAAE,aAAa,CAAC,aAAa,EACnC,SAAS,EAAE,KAAK,CAAC,SAAS,uDAO3B;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oHAsBxB,CAAA;AAED,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,CAAC,aAAa,CAMtE;AAED,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAMpD"}

package/types/Ledger/TxHash.d.ts

@@ -0,0 +1,70 @@
+import { Effect, Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import * as Cbor from "../Cbor.js";
+import { Data } from "../Uplc/index.js";
+export declare function isValid(hash: string): hash is TxHash;
+export declare const TxHash: Schema.brand<Schema.filter<typeof Schema.String>, "TxHash">;
+export type TxHash = Schema.Schema.Type<typeof TxHash>;
+export declare const FromUplcData: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+    readonly bytes: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly int: bigint;
+} | {
+    readonly list: readonly Data.Data[];
+} | {
+    readonly map: readonly {
+        readonly k: Data.Data;
+        readonly v: Data.Data;
+    }[];
+} | {
+    readonly fields: readonly Data.Data[];
+    readonly constructor: number;
+}, {
+    readonly bytes: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly int: bigint;
+} | {
+    readonly list: readonly Data.Data[];
+} | {
+    readonly map: readonly {
+        readonly k: Data.Data;
+        readonly v: Data.Data;
+    }[];
+} | {
+    readonly fields: readonly Data.Data[];
+    readonly constructor: number;
+}, never>, Schema.Struct<{
+    bytes: Schema.transformOrFail<Schema.SchemaClass<{
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Data.Data;
+            readonly v: Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Data.Data[];
+        readonly constructor: number;
+    }, {
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Data.Data;
+            readonly v: Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Data.Data[];
+        readonly constructor: number;
+    }, never>, typeof Schema.Uint8ArrayFromSelf, never>;
+}>, never>, Schema.brand<Schema.filter<typeof Schema.String>, "TxHash">>;
+export declare function make(txId: Bytes.BytesLike): Effect.Effect<string & import("effect/Brand").Brand<"TxHash">, import("effect/ParseResult").ParseError, never>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeEffect<TxHash>;
+export declare function encode(txId: TxHash): number[];
+//# sourceMappingURL=TxHash.d.ts.map

package/types/Ledger/TxHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TxHash.d.ts","sourceRoot":"","sources":["../../src/Ledger/TxHash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,KAAK,IAAI,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAEvC,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,MAAM,CAEpD;AAED,eAAO,MAAM,MAAM,6DAGlB,CAAA;AAED,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,CAAA;AAEtD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wEAUxB,CAAA;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,kHAEzC;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAOrE,CAAA;AAEH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAE7C"}

package/types/Ledger/UTxO.d.ts

@@ -0,0 +1,55 @@
+import { Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import * as Cbor from "../Cbor.js";
+import * as TxOutput from "./TxOutput.js";
+import * as UTxORef from "./UTxORef.js";
+export declare const UTxO: Schema.TaggedStruct<"UTxO", {
+    ref: Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "UTxORef">>;
+    output: Schema.TaggedStruct<"TxOutput", {
+        address: Schema.brand<Schema.filter<typeof Schema.String>, "Address">;
+        assets: Schema.filter<Schema.Record$<typeof Schema.String, typeof Schema.BigIntFromSelf>>;
+        datum: Schema.optional<Schema.Union<[Schema.TaggedStruct<"Inline", {
+            data: Schema.SchemaClass<{
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly import("../Uplc/Data.js").Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: import("../Uplc/Data.js").Data;
+                    readonly v: import("../Uplc/Data.js").Data;
+                }[];
+            } | {
+                readonly fields: readonly import("../Uplc/Data.js").Data[];
+                readonly constructor: number;
+            }, {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly import("../Uplc/Data.js").Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: import("../Uplc/Data.js").Data;
+                    readonly v: import("../Uplc/Data.js").Data;
+                }[];
+            } | {
+                readonly fields: readonly import("../Uplc/Data.js").Data[];
+                readonly constructor: number;
+            }, never>;
+        }>, Schema.TaggedStruct<"Hash", {
+            hash: Schema.brand<Schema.filter<typeof Schema.String>, "DatumHash">;
+        }>]>>;
+        refScript: Schema.optional<typeof Schema.Uint8ArrayFromSelf>;
+        encodingConfig: Schema.Struct<{
+            strictBabbage: Schema.optional<typeof Schema.Boolean>;
+        }>;
+    }>;
+}>;
+export type UTxO = Schema.Schema.Type<typeof UTxO>;
+export declare function make(ref: UTxORef.UTxORef, output: TxOutput.TxOutput): UTxO;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeEffect<UTxO | UTxORef.UTxORef>;
+export declare const decodeFull: (bytes: Bytes.BytesLike) => Cbor.DecodeEffect<UTxO>;
+export declare function encode(txInput: UTxO, full?: boolean): number[];
+//# sourceMappingURL=UTxO.d.ts.map

package/types/Ledger/UTxO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UTxO.d.ts","sourceRoot":"","sources":["../../src/Ledger/UTxO.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,KAAK,IAAI,MAAM,YAAY,CAAA;AAClC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGf,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAA;AAElD,wBAAgB,IAAI,CAClB,GAAG,EAAE,OAAO,CAAC,OAAO,EACpB,MAAM,EAAE,QAAQ,CAAC,QAAQ,GACxB,IAAI,CAMN;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,IAAI,GAAG,OAAO,CAAC,OAAO,CAepF,CAAA;AAEJ,eAAO,MAAM,UAAU,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAGR,CAAA;AAElE,wBAAgB,MAAM,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,GAAE,OAAe,YAS1D"}

package/types/Ledger/UTxORef.d.ts

@@ -0,0 +1,133 @@
+import { Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import * as Cbor from "../Cbor.js";
+import * as Uplc from "../Uplc/index.js";
+import * as TxHash from "./TxHash.js";
+export declare function isValid(ref: string): ref is UTxORef;
+export declare const UTxORef: Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "UTxORef">>;
+export type UTxORef = Schema.Schema.Type<typeof UTxORef>;
+export declare function make(txHash: TxHash.TxHash, index: number | bigint): UTxORef;
+export declare const FromUplcData: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+    readonly bytes: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly int: bigint;
+} | {
+    readonly list: readonly Uplc.Data.Data[];
+} | {
+    readonly map: readonly {
+        readonly k: Uplc.Data.Data;
+        readonly v: Uplc.Data.Data;
+    }[];
+} | {
+    readonly fields: readonly Uplc.Data.Data[];
+    readonly constructor: number;
+}, {
+    readonly bytes: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly int: bigint;
+} | {
+    readonly list: readonly Uplc.Data.Data[];
+} | {
+    readonly map: readonly {
+        readonly k: Uplc.Data.Data;
+        readonly v: Uplc.Data.Data;
+    }[];
+} | {
+    readonly fields: readonly Uplc.Data.Data[];
+    readonly constructor: number;
+}, never>, Schema.Struct<{
+    txHash: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.Data.Data[];
+        readonly constructor: number;
+    }, {
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.Data.Data[];
+        readonly constructor: number;
+    }, never>, Schema.Struct<{
+        bytes: Schema.transformOrFail<Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.Data.Data[];
+            readonly constructor: number;
+        }, never>, typeof Schema.Uint8ArrayFromSelf, never>;
+    }>, never>, Schema.brand<Schema.filter<typeof Schema.String>, "TxHash">>;
+    index: Schema.transformOrFail<Schema.SchemaClass<{
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.Data.Data[];
+        readonly constructor: number;
+    }, {
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.Data.Data[];
+        readonly constructor: number;
+    }, never>, typeof Schema.Int, never>;
+}>, never>, Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "UTxORef">>>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeEffect<UTxORef>;
+export declare function encode(ref: UTxORef): number[];
+export declare function pretty(ref: UTxORef): string;
+export declare function txHash(ref: UTxORef): TxHash.TxHash;
+export declare function index(ref: UTxORef): number;
+//# sourceMappingURL=UTxORef.d.ts.map

package/types/Ledger/UTxORef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UTxORef.d.ts","sourceRoot":"","sources":["../../src/Ledger/UTxORef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,KAAK,IAAI,MAAM,YAAY,CAAA;AAClC,OAAO,KAAK,IAAI,MAAM,kBAAkB,CAAA;AACxC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,OAAO,CAanD;AAED,eAAO,MAAM,OAAO,sGAWnB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC,CAAA;AAExD,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAE3E;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iHAkBxB,CAAA;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAGtE,CAAA;AAEH,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,EAAE,CAK7C;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAE3C;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,CAElD;AAED,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAE1C"}

package/types/Ledger/index.d.ts

@@ -3,14 +3,12 @@ export * as AssetClass from "./AssetClass.js";
 export * as Assets from "./Assets.js";
 export * as Credential from "./Credential.js";
 export * as DatumHash from "./DatumHash.js";
-export { IsMainnet } from "./IsMainnet.js";
 export * as MintingPolicy from "./MintingPolicy.js";
-export * as NetworkParams from "./NetworkParams.js";
 export * as PubKeyHash from "./PubKeyHash.js";
-export * as TxId from "./TxId.js";
-export * as TxInput from "./TxInput.js";
+export * as TxHash from "./TxHash.js";
+export * as UTxO from "./UTxO.js";
 export * as TxOutput from "./TxOutput.js";
 export * as TxOutputDatum from "./TxOutputDatum.js";
-export * as TxOutputId from "./TxOutputId.js";
+export * as UTxORef from "./UTxORef.js";
 export * as ValidatorHash from "./ValidatorHash.js";
 //# sourceMappingURL=index.d.ts.map

package/types/Ledger/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Ledger/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Ledger/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA"}

package/types/Network/IsMainnet.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "effect";
+declare const IsMainnet_base: Context.TagClass<IsMainnet, "NetworkIsMainnet", boolean>;
+export declare class IsMainnet extends IsMainnet_base {
+}
+export {};
+//# sourceMappingURL=IsMainnet.d.ts.map

package/types/Network/IsMainnet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsMainnet.d.ts","sourceRoot":"","sources":["../../src/Network/IsMainnet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;;AAEhC,qBAAa,SAAU,SAAQ,cAG5B;CAAG"}

package/types/Network/Params.d.ts

@@ -0,0 +1,45 @@
+import { Context, Effect, Schema } from "effect";
+import { ConnectionError, UnexpectedFormat } from "./errors.js";
+/**
+ * The raw JSON can be downloaded from the following CDN locations:
+ *
+ *  - Preview: [https://network-status.helios-lang.io/preview/config](https://network-status.helios-lang.io/preview/config)
+ *  - Preprod: [https://network-status.helios-lang.io/preprod/config](https://network-status.helios-lang.io/preprod/config)
+ *  - Mainnet: [https://network-status.helios-lang.io/mainnet/config](https://network-status.helios-lang.io/mainnet/config)
+ *
+ * These JSONs are updated every 15 minutes.
+ *
+ * Only include the minimum fields needed. flattened so it can be extended more easily
+ *
+ * NetworkParams are a summary of the Era-specific params, relevant for tx building and validation
+ *
+ * Optionally, NetworkParams returned by a private node can specify a `collateralUTXO` to use (<txID>#<outputIndex> format). Any transaction submitted through that same node will then add the signature necessary to spend the collateral UTXO.
+ * This allows the collateral UTXO managed to be done in a central place (i.e. the node).
+ */
+export declare const Params: Schema.Struct<{
+    txFeeFixed: typeof Schema.Number;
+    txFeePerByte: typeof Schema.Number;
+    exMemFeePerUnit: typeof Schema.Number;
+    exCpuFeePerUnit: typeof Schema.Number;
+    utxoDepositPerByte: typeof Schema.Number;
+    refScriptsFeePerByte: typeof Schema.Number;
+    collateralPercentage: typeof Schema.Number;
+    maxCollateralInputs: typeof Schema.Number;
+    maxTxExMem: typeof Schema.Number;
+    maxTxExCpu: typeof Schema.Number;
+    maxTxSize: typeof Schema.Number;
+    secondsPerSlot: typeof Schema.Number;
+    stakeAddrDeposit: typeof Schema.Number;
+    refTopSlot: typeof Schema.Number;
+    refTipTime: typeof Schema.Number;
+    costModelParamsV1: Schema.Array$<typeof Schema.Number>;
+    costModelParamsV2: Schema.Array$<typeof Schema.Number>;
+    costModelParamsV3: Schema.Array$<typeof Schema.Number>;
+    collateralUTXO: Schema.optional<Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "UTxORef">>>;
+}>;
+export type Params = Schema.Schema.Type<typeof Params>;
+declare const Fetch_base: Context.TagClass<Fetch, "NetworkParamsFetch", () => Effect.Effect<Params, ConnectionError | UnexpectedFormat, never>>;
+export declare class Fetch extends Fetch_base {
+}
+export {};
+//# sourceMappingURL=Params.d.ts.map

package/types/Network/Params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Params.d.ts","sourceRoot":"","sources":["../../src/Network/Params.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEhD,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE/D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;EAoBjB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,CAAA;8EAI9C,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,gBAAgB,EAAE,KAAK,CAAC;AAFxE,qBAAa,KAAM,SAAQ,UAGxB;CAAG"}

package/types/Network/UTxOsAt.d.ts

@@ -0,0 +1,9 @@
+import { Context, Effect } from "effect";
+import { Address } from "../Ledger/Address.js";
+import { UTxO } from "../Ledger/UTxO.js";
+import { ConnectionError, UnexpectedFormat } from "./errors";
+declare const UTxOsAt_base: Context.TagClass<UTxOsAt, "NetworkUTxOsAt", (address: Address) => Effect.Effect<UTxO[], ConnectionError | UnexpectedFormat>>;
+export declare class UTxOsAt extends UTxOsAt_base {
+}
+export {};
+//# sourceMappingURL=UTxOsAt.d.ts.map

package/types/Network/UTxOsAt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UTxOsAt.d.ts","sourceRoot":"","sources":["../../src/Network/UTxOsAt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAC9C,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AACxC,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;kFAI9C,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,eAAe,GAAG,gBAAgB,CAAC;AAFnF,qBAAa,OAAQ,SAAQ,YAG1B;CAAG"}

package/types/Network/errors.d.ts

@@ -0,0 +1,18 @@
+declare const ConnectionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "CardanoNetworkConnectionError";
+} & Readonly<A>;
+export declare class ConnectionError extends ConnectionError_base<{
+    message: string;
+}> {
+    constructor(message: string);
+}
+declare const UnexpectedFormat_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "CardanoNetworkUnexpectedFormat";
+} & Readonly<A>;
+export declare class UnexpectedFormat extends UnexpectedFormat_base<{
+    message: string;
+}> {
+    constructor(message: string);
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/types/Network/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/Network/errors.ts"],"names":[],"mappings":";;;AAEA,qBAAa,eAAgB,SAAQ,qBAAkD;IACnF,OAAO,EAAE,MAAM,CAAA;CAClB,CAAC;gBACc,OAAO,EAAE,MAAM;CAK9B;;;;AAED,qBAAa,gBAAiB,SAAQ,sBAAmD;IACrF,OAAO,EAAE,MAAM,CAAA;CAClB,CAAC;gBACc,OAAO,EAAE,MAAM;CAK9B"}

package/types/Network/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./errors.js";
+export * from "./IsMainnet.js";
+export * as Params from "./Params.js";
+export * from "./UTxOsAt.js";
+//# sourceMappingURL=index.d.ts.map

package/types/Network/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Network/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,cAAc,cAAc,CAAA"}

package/types/index.d.ts

@@ -1,5 +1,6 @@
 export * as Bech32 from "./Bech32.js";
 export * as Cbor from "./Cbor.js";
 export * as Ledger from "./Ledger";
+export * as Network from "./Network";
 export * as Uplc from "./Uplc";
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAA"}