@helios-lang/effect 0.1.14 → 0.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"UTxO.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/UTxO.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,222 @@
+import { Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import * as Cbor from "../../Codecs/Cbor.js";
+import * as Data from "../Uplc/Data.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 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<{
+    txHash: 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">>;
+    index: 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.Int, never>;
+}>, never>, Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "UTxORef">>>;
+export declare const FromUplcDataV3: 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<{
+    txHash: 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>, typeof Schema.String, never>, Schema.brand<Schema.filter<typeof Schema.String>, "TxHash">>;
+    index: 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.Int, never>;
+}>, never>, Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "UTxORef">>>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<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;
+export declare function compare(a: UTxORef, b: UTxORef): number;
+//# sourceMappingURL=UTxORef.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UTxORef.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/UTxORef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAA;AAC9C,OAAO,KAAK,IAAI,MAAM,sBAAsB,CAAA;AAC5C,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAA;AACvC,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,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iHAkB1B,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;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAQtD"}

package/types/{Ledger → Cardano/Ledger}/ValidatorHash.d.ts

@@ -1,11 +1,11 @@
-import { Effect, Schema } from "effect";
-import * as Bytes from "../internal/Bytes.js";
-import { DecodeEffect } from "../Cbor.js";
+import { Either, Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import { DecodeResult } from "../../Codecs/Cbor.js";
 import { Data } from "../Uplc";
 export declare function isValid(vh: string): boolean;
 export declare const ValidatorHash: Schema.brand<Schema.filter<typeof Schema.String>, "ValidatorHash">;
 export type ValidatorHash = Schema.Schema.Type<typeof ValidatorHash>;
-export declare function make(bytes: Bytes.BytesLike): Effect.Effect<string & import("effect/Brand").Brand<"ValidatorHash">, import("effect/ParseResult").ParseError, never>;
+export declare function make(bytes: Bytes.BytesLike): Either.Either<string & import("effect/Brand").Brand<"ValidatorHash">, import("effect/ParseResult").ParseError>;
 export declare const FromUplcData: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
     readonly bytes: Uint8Array<ArrayBufferLike>;
 } | {
@@ -35,6 +35,6 @@ export declare const FromUplcData: Schema.transform<Schema.transformOrFail<Schem
     readonly fields: readonly Data.Data[];
     readonly constructor: number;
 }, never>, typeof Schema.Uint8ArrayFromSelf, never>, Schema.brand<Schema.filter<typeof Schema.String>, "ValidatorHash">>;
-export declare const decode: (bytes: Bytes.BytesLike) => DecodeEffect<ValidatorHash>;
+export declare const decode: (bytes: Bytes.BytesLike) => DecodeResult<ValidatorHash>;
 export declare function encode(vh: ValidatorHash): number[];
 //# sourceMappingURL=ValidatorHash.d.ts.map

package/types/Cardano/Ledger/ValidatorHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidatorHash.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/ValidatorHash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAA;AAC9C,OAAO,EAAe,YAAY,EAAe,MAAM,sBAAsB,CAAA;AAC7E,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAE9B,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE3C;AAED,eAAO,MAAM,aAAa,oEAGzB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAA;AAEpE,wBAAgB,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,kHAE1C;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;wHAIvB,CAAA;AAEF,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,YAAY,CAAC,aAAa,CAKvE,CAAA;AAEH,wBAAgB,MAAM,CAAC,EAAE,EAAE,aAAa,GAAG,MAAM,EAAE,CAElD"}

package/types/{Ledger → Cardano/Ledger}/index.d.ts

@@ -3,8 +3,13 @@ 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 * as DCert from "./DCert.js";
 export * as MintingPolicy from "./MintingPolicy.js";
+export * as NativeScript from "./NativeScript.js";
 export * as PubKeyHash from "./PubKeyHash.js";
+export * as Redeemer from "./Redeemer.js";
+export * as RewardAddress from "./RewardAddress.js";
+export * as Tx from "./Tx.js";
 export * as TxHash from "./TxHash.js";
 export * as UTxO from "./UTxO.js";
 export * as TxOutput from "./TxOutput.js";

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Cardano/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,KAAK,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,EAAE,MAAM,SAAS,CAAA;AAC7B,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/Cardano/Network/IsMainnet.d.ts.map

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

package/types/{Network → Cardano/Network}/Params.d.ts

@@ -1,5 +1,4 @@
 import { Context, Effect, Schema } from "effect";
-import { ConnectionError, UnexpectedFormat } from "./errors.js";
 /**
  * The raw JSON can be downloaded from the following CDN locations:
  *
@@ -30,7 +29,7 @@ export declare const Params: Schema.Struct<{
     maxTxSize: typeof Schema.Number;
     secondsPerSlot: typeof Schema.Number;
     stakeAddrDeposit: typeof Schema.Number;
-    refTopSlot: typeof Schema.Number;
+    refTipSlot: typeof Schema.Number;
     refTipTime: typeof Schema.Number;
     costModelParamsV1: Schema.Array$<typeof Schema.Number>;
     costModelParamsV2: Schema.Array$<typeof Schema.Number>;
@@ -38,8 +37,37 @@ export declare const Params: Schema.Struct<{
     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 {
+declare const params_base: Context.TagClass<params, "Network.Params.params", {
+    readonly txFeeFixed: number;
+    readonly txFeePerByte: number;
+    readonly exMemFeePerUnit: number;
+    readonly exCpuFeePerUnit: number;
+    readonly utxoDepositPerByte: number;
+    readonly refScriptsFeePerByte: number;
+    readonly collateralPercentage: number;
+    readonly maxCollateralInputs: number;
+    readonly maxTxExMem: number;
+    readonly maxTxExCpu: number;
+    readonly maxTxSize: number;
+    readonly secondsPerSlot: number;
+    readonly stakeAddrDeposit: number;
+    readonly refTipSlot: number;
+    readonly refTipTime: number;
+    readonly costModelParamsV1: readonly number[];
+    readonly costModelParamsV2: readonly number[];
+    readonly costModelParamsV3: readonly number[];
+    readonly collateralUTXO?: (string & import("effect/Brand").Brand<"UTxORef">) | undefined;
+}>;
+export declare class params extends params_base {
 }
+/**
+ * Calculates the time (in milliseconds in 01/01/1970) associated with a given slot number.
+ */
+export declare const slotToTime: (slot: number) => Effect.Effect<number, never, params>;
+/**
+ * Calculates the slot number associated with a given time. Time is specified as milliseconds since 01/01/1970.
+ */
+export declare const timeToSlot: (time: number) => Effect.Effect<number, never, params>;
+export declare const costModel: (version: 1 | 2 | 3) => Effect.Effect<readonly number[], never, params>;
 export {};
 //# sourceMappingURL=Params.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Params.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Network/Params.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAGhD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;EAoBjB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,CAAA;;;;;;;;;;;;;;;;;;;;;;AAEtD,qBAAa,MAAO,SAAQ,WAGzB;CAAG;AAEN;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,yCAOpC,CAAA;AAEH;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,yCAOpC,CAAA;AAEH,eAAO,MAAM,SAAS,GAAI,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,oDAYzC,CAAA"}

package/types/Cardano/Network/UTxO.d.ts

@@ -0,0 +1,15 @@
+import { Context, Effect } from "effect";
+import type { UTxO } from "../Ledger/UTxO.js";
+import type { UTxORef } from "../Ledger/UTxORef.js";
+import { ConnectionError, UnexpectedFormat, UTxOAlreadySpent, UTxONotFound } from "./errors.js";
+declare const UTxO$_base: Context.TagClass<UTxO$, "Network.UTxO", (ref: UTxORef) => Effect.Effect<UTxO, ConnectionError | UnexpectedFormat | UTxONotFound | UTxOAlreadySpent>>;
+declare class UTxO$ extends UTxO$_base {
+}
+export { UTxO$ as UTxO };
+/**
+ * Usefuly for testing
+ * @param knownUTxOs
+ * @returns
+ */
+export declare const provideKnownUTxOs: (knownUTxOs: Record<string, UTxO>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, UTxO$>>;
+//# sourceMappingURL=UTxO.d.ts.map

package/types/Cardano/Network/UTxO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UTxO.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Network/UTxO.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,EACb,MAAM,aAAa,CAAA;wEAMX,OAAO,KACT,MAAM,CAAC,MAAM,CAChB,IAAI,EACJ,eAAe,GAAG,gBAAgB,GAAG,YAAY,GAAG,gBAAgB,CACrE;AAPH,cAAM,KAAM,SAAQ,UAQjB;CAAG;AAEN,OAAO,EAAE,KAAK,IAAI,IAAI,EAAE,CAAA;AAExB;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,sFAO9D,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"UTxOsAt.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Network/UTxOsAt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;mFAK/C,OAAO,KACb,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,eAAe,GAAG,gBAAgB,CAAC;AAJhE,qBAAa,OAAQ,SAAQ,YAK1B;CAAG"}

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

@@ -0,0 +1,39 @@
+import type { TxHash } from "../Ledger/TxHash.js";
+import type { UTxORef } from "../Ledger/UTxORef.js";
+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);
+}
+declare const UTxONotFound_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: "Cardano.Network.UTxONotFound";
+} & Readonly<A>;
+export declare class UTxONotFound extends UTxONotFound_base<{
+    message: string;
+    ref: UTxORef;
+}> {
+    constructor(ref: UTxORef);
+}
+declare const UTxOAlreadySpent_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: "Cardano.Network.UTxOAlreadySpent";
+} & Readonly<A>;
+export declare class UTxOAlreadySpent extends UTxOAlreadySpent_base<{
+    message: string;
+    ref: UTxORef;
+    spendingTx: TxHash;
+}> {
+    constructor(ref: UTxORef, spendingTx: TxHash);
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Network/errors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;;;;AAEnD,qBAAa,eAAgB,SAAQ,qBAEnC;IACA,OAAO,EAAE,MAAM,CAAA;CAChB,CAAC;gBACY,OAAO,EAAE,MAAM;CAK5B;;;;AAED,qBAAa,gBAAiB,SAAQ,sBAEpC;IACA,OAAO,EAAE,MAAM,CAAA;CAChB,CAAC;gBACY,OAAO,EAAE,MAAM;CAK5B;;;;AAED,qBAAa,YAAa,SAAQ,kBAEhC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,CAAC;gBACtB,GAAG,EAAE,OAAO;CAMzB;;;;AAED,qBAAa,gBAAiB,SAAQ,sBAEpC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;gBAC1C,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM;CAO7C"}

package/types/{Network → Cardano/Network}/index.d.ts

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

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

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