@helios-lang/effect 0.1.5 → 0.1.7

package/types/Ledger/Assets.d.ts

@@ -0,0 +1,70 @@
+import { Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import * as Cbor from "../Cbor.js";
+import { Data } from "../Uplc";
+import * as AssetClass from "./AssetClass.js";
+export declare const Assets: Schema.filter<Schema.Record$<typeof Schema.String, typeof Schema.BigIntFromSelf>>;
+export type Assets = Schema.Schema.Type<typeof Assets>;
+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.Array$<Schema.Tuple2<Schema.Schema<import("effect/Option").Option<string & import("effect/Brand").Brand<"ValidatorHash">>, {
+    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.Schema<readonly (readonly [string, bigint])[], {
+    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>>>, never>, Schema.filter<Schema.Record$<typeof Schema.String, typeof Schema.BigIntFromSelf>>>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeEffect<Assets>;
+export declare function encode(assets: Assets): number[];
+export declare function allAssetClasses(assets: Assets): AssetClass.AssetClass[];
+export declare function nonAdaAssetClasses(assets: Assets): AssetClass.AssetClass[];
+export declare function lovelace(assets: Assets): bigint;
+//# sourceMappingURL=Assets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Assets.d.ts","sourceRoot":"","sources":["../../src/Ledger/Assets.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,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAG7C,eAAO,MAAM,MAAM,mFAalB,CAAA;AAED,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,CAAA;AAEtD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uGA+BxB,CAAA;AA4BD,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAsCpE,CAAA;AAEJ,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CA4B/C;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,UAAU,EAAE,CAEvE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,UAAU,EAAE,CAE1E;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE/C"}

package/types/Ledger/Credential.d.ts

@@ -0,0 +1,26 @@
+import { Schema } from "effect";
+import { Data } from "../Uplc";
+import { PubKeyHash } from "./PubKeyHash.js";
+import { ValidatorHash } from "./ValidatorHash.js";
+export declare const Credential: Schema.Union<[Schema.TaggedStruct<"PubKey", {
+    hash: Schema.brand<Schema.filter<typeof Schema.String>, "PubKeyHash">;
+}>, Schema.TaggedStruct<"Validator", {
+    hash: Schema.brand<Schema.filter<typeof Schema.String>, "ValidatorHash">;
+}>]>;
+export type Credential = Schema.Schema.Type<typeof Credential>;
+export declare function makePubKey(pkh: PubKeyHash): Credential;
+export declare function makeValidator(vh: ValidatorHash): Credential;
+export declare const FromUplcData: Schema.transform<Schema.Schema<({
+    _tag: "PubKey";
+} & {
+    hash: string;
+}) | ({
+    _tag: "Validator";
+} & {
+    hash: string;
+}), Data.Data, never>, Schema.Union<[Schema.TaggedStruct<"PubKey", {
+    hash: Schema.brand<Schema.filter<typeof Schema.String>, "PubKeyHash">;
+}>, Schema.TaggedStruct<"Validator", {
+    hash: Schema.brand<Schema.filter<typeof Schema.String>, "ValidatorHash">;
+}>]>>;
+//# sourceMappingURL=Credential.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Credential.d.ts","sourceRoot":"","sources":["../../src/Ledger/Credential.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAElD,eAAO,MAAM,UAAU;;;;IAGtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9D,wBAAgB,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU,CAEtD;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,aAAa,GAAG,UAAU,CAE3D;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;KAQxB,CAAA"}

package/types/Ledger/DatumHash.d.ts

@@ -0,0 +1,40 @@
+import { Effect, Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import { DecodeEffect } from "../Cbor.js";
+import { Data } from "../Uplc";
+export declare function isValid(dh: string): boolean;
+export declare const DatumHash: Schema.brand<Schema.filter<typeof Schema.String>, "DatumHash">;
+export type DatumHash = Schema.Schema.Type<typeof DatumHash>;
+export declare function make(bytes: Bytes.BytesLike): Effect.Effect<string & import("effect/Brand").Brand<"DatumHash">, import("effect/ParseResult").ParseError, never>;
+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>, typeof Schema.Uint8ArrayFromSelf, never>, Schema.brand<Schema.filter<typeof Schema.String>, "DatumHash">>;
+export declare const decode: (bytes: Bytes.BytesLike) => DecodeEffect<DatumHash>;
+export declare function encode(dh: DatumHash): number[];
+//# sourceMappingURL=DatumHash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DatumHash.d.ts","sourceRoot":"","sources":["../../src/Ledger/DatumHash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAe,YAAY,EAAe,MAAM,YAAY,CAAA;AACnE,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAE9B,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE3C;AAED,eAAO,MAAM,SAAS,gEAGrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,CAAA;AAE5D,wBAAgB,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,qHAE1C;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;oHAIvB,CAAA;AAEF,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,YAAY,CAAC,SAAS,CAKnE,CAAA;AAEH,wBAAgB,MAAM,CAAC,EAAE,EAAE,SAAS,GAAG,MAAM,EAAE,CAE9C"}

package/types/Ledger/IsMainnet.d.ts

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

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

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

package/types/Ledger/MintingPolicy.d.ts

@@ -0,0 +1,39 @@
+import { Effect, Option, Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import * as Cbor from "../Cbor.js";
+import { Data } from "../Uplc";
+export declare const MintingPolicy: Schema.Option<Schema.brand<Schema.filter<typeof Schema.String>, "ValidatorHash">>;
+export type MintingPolicy = Schema.Schema.Type<typeof MintingPolicy>;
+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>, typeof Schema.Uint8ArrayFromSelf, never>, Schema.Option<Schema.brand<Schema.filter<typeof Schema.String>, "ValidatorHash">>>;
+export declare function make(policy: Bytes.BytesLike): Effect.Effect<Option.Option<string & import("effect/Brand").Brand<"ValidatorHash">>, import("effect/ParseResult").ParseError, never>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeEffect<MintingPolicy>;
+export declare function encode(policy: MintingPolicy): number[];
+//# sourceMappingURL=MintingPolicy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MintingPolicy.d.ts","sourceRoot":"","sources":["../../src/Ledger/MintingPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACzD,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,KAAK,IAAI,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAI9B,eAAO,MAAM,aAAa,mFAA6C,CAAA;AAEvE,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAA;AAEpE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;uIAgBvB,CAAA;AAEF,wBAAgB,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,wIAQ3C;AAED,eAAO,MAAM,MAAM,GACjB,OAAO,KAAK,CAAC,SAAS,KACrB,IAAI,CAAC,YAAY,CAAC,aAAa,CAO/B,CAAA;AAEH,wBAAgB,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,EAAE,CAMtD"}

package/{src/Ledger/NetworkParams.ts → types/Ledger/NetworkParams.d.ts}

@@ -1,6 +1,4 @@
-import { Schema } from "effect"
-import * as TxOutputId from "./TxOutputId.js"
-
+import { Schema } from "effect";
 /**
  * The raw JSON can be downloaded from the following CDN locations:
  *
@@ -17,26 +15,26 @@ import * as TxOutputId from "./TxOutputId.js"
  * 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 const NetworkParams = Schema.Struct({
-  txFeeFixed: Schema.Number,
-  txFeePerByte: Schema.Number,
-  exMemFeePerUnit: Schema.Number,
-  exCpuFeePerUnit: Schema.Number,
-  utxoDepositPerByte: Schema.Number,
-  refScriptsFeePerByte: Schema.Number,
-  collateralPercentage: Schema.Number,
-  maxCollateralInputs: Schema.Number,
-  maxTxExMem: Schema.Number,
-  maxTxExCpu: Schema.Number,
-  maxTxSize: Schema.Number,
-  secondsPerSlot: Schema.Number,
-  stakeAddrDeposit: Schema.Number,
-  refTopSlot: Schema.Number,
-  refTipTime: Schema.Number,
-  costModelParamsV1: Schema.Array(Schema.Number),
-  costModelParamsV2: Schema.Array(Schema.Number),
-  costModelParamsV3: Schema.Array(Schema.Number),
-  collateralUTXO: Schema.optional(TxOutputId.TxOutputId)
-})
-
-export type NetworkParams = Schema.Schema.Type<typeof NetworkParams>
+export declare const NetworkParams: 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>, "TxOutputId">>>;
+}>;
+export type NetworkParams = Schema.Schema.Type<typeof NetworkParams>;
+//# sourceMappingURL=NetworkParams.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkParams.d.ts","sourceRoot":"","sources":["../../src/Ledger/NetworkParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAG/B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;EAoBxB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAA"}

package/types/Ledger/PubKeyHash.d.ts

@@ -0,0 +1,40 @@
+import { Effect, Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import { DecodeEffect } from "../Cbor.js";
+import { Data } from "../Uplc";
+export declare function isValid(pkh: string): pkh is PubKeyHash;
+export declare const PubKeyHash: Schema.brand<Schema.filter<typeof Schema.String>, "PubKeyHash">;
+export type PubKeyHash = Schema.Schema.Type<typeof PubKeyHash>;
+export declare function make(bytes: Bytes.BytesLike): Effect.Effect<string & import("effect/Brand").Brand<"PubKeyHash">, import("effect/ParseResult").ParseError, never>;
+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>, typeof Schema.Uint8ArrayFromSelf, never>, Schema.brand<Schema.filter<typeof Schema.String>, "PubKeyHash">>;
+export declare const decode: (bytes: Bytes.BytesLike) => DecodeEffect<PubKeyHash>;
+export declare function encode(pkh: PubKeyHash): number[];
+//# sourceMappingURL=PubKeyHash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PubKeyHash.d.ts","sourceRoot":"","sources":["../../src/Ledger/PubKeyHash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAe,YAAY,EAAe,MAAM,YAAY,CAAA;AACnE,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAE9B,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,UAAU,CAEtD;AAED,eAAO,MAAM,UAAU,iEAGtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9D,wBAAgB,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,sHAE1C;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;qHAIvB,CAAA;AAEF,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,YAAY,CAAC,UAAU,CAKpE,CAAA;AAEH,wBAAgB,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,EAAE,CAEhD"}

package/types/Ledger/TxId.d.ts

@@ -0,0 +1,10 @@
+import { Effect, Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import * as Cbor from "../Cbor.js";
+export declare function isValid(txId: string): txId is TxId;
+export declare const TxId: Schema.brand<Schema.filter<typeof Schema.String>, "TxId">;
+export type TxId = Schema.Schema.Type<typeof TxId>;
+export declare function make(txId: Bytes.BytesLike): Effect.Effect<string & import("effect/Brand").Brand<"TxId">, import("effect/ParseResult").ParseError, never>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeEffect<TxId>;
+export declare function encode(txId: TxId): number[];
+//# sourceMappingURL=TxId.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TxId.d.ts","sourceRoot":"","sources":["../../src/Ledger/TxId.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,KAAK,IAAI,MAAM,YAAY,CAAA;AAElC,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,IAAI,CAElD;AAED,eAAO,MAAM,IAAI,2DAGhB,CAAA;AAED,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAA;AAElD,wBAAgB,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,gHAEzC;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAOnE,CAAA;AAEH,wBAAgB,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,CAE3C"}

package/types/Ledger/TxInput.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 TxOutputId from "./TxOutputId.js";
+export declare const TxInput: Schema.TaggedStruct<"TxInput", {
+    id: Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "TxOutputId">>;
+    output: Schema.optional<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 TxInput = Schema.Schema.Type<typeof TxInput>;
+export declare function make(id: TxOutputId.TxOutputId, output?: TxOutput.TxOutput | undefined): TxInput;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeEffect<TxInput>;
+export declare function encode(txInput: TxInput, full?: boolean): number[];
+export declare function output(txInput: TxInput): TxOutput.TxOutput;
+//# sourceMappingURL=TxInput.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TxInput.d.ts","sourceRoot":"","sources":["../../src/Ledger/TxInput.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,UAAU,MAAM,iBAAiB,CAAA;AAE7C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC,CAAA;AAExD,wBAAgB,IAAI,CAClB,EAAE,EAAE,UAAU,CAAC,UAAU,EACzB,MAAM,GAAE,QAAQ,CAAC,QAAQ,GAAG,SAAqB,GAChD,OAAO,CAMT;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAsBrE,CAAA;AAEJ,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,GAAE,OAAe,YAS7D;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAAC,QAAQ,CAM1D"}

package/types/Ledger/TxOutput.d.ts

@@ -0,0 +1,63 @@
+import { Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import * as Cbor from "../Cbor.js";
+import * as Address from "./Address.js";
+import * as Assets from "./Assets.js";
+import * as TxOutputDatum from "./TxOutputDatum.js";
+export declare const TxOutputEncodingConfig: Schema.Struct<{
+    strictBabbage: Schema.optional<typeof Schema.Boolean>;
+}>;
+export type TxOutputEncodingConfig = Schema.Schema.Type<typeof TxOutputEncodingConfig>;
+export declare const DEFAULT_TX_OUTPUT_ENCODING_CONFIG: TxOutputEncodingConfig;
+export declare const TxOutput: 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 TxOutput = Schema.Schema.Type<typeof TxOutput>;
+export declare function make({ address, assets, datum, refScript, encodingConfig }: {
+    address: Address.Address;
+    assets: Assets.Assets;
+    datum?: TxOutputDatum.TxOutputDatum;
+    refScript?: Uint8Array;
+    encodingConfig?: TxOutputEncodingConfig;
+}): TxOutput;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeEffect<TxOutput>;
+export declare function encode(txOutput: TxOutput): number[];
+//# sourceMappingURL=TxOutput.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TxOutput.d.ts","sourceRoot":"","sources":["../../src/Ledger/TxOutput.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,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD,eAAO,MAAM,sBAAsB;;EAEjC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CACrD,OAAO,sBAAsB,CAC9B,CAAA;AAED,eAAO,MAAM,iCAAiC,EAAE,sBAE/C,CAAA;AAGD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE1D,wBAAgB,IAAI,CAAC,EACnB,OAAO,EACP,MAAM,EACN,KAAiB,EACjB,SAAqB,EACrB,cAAkD,EACnD,EAAE;IACD,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;IACxB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,aAAa,CAAC,aAAa,CAAA;IACnC,SAAS,CAAC,EAAE,UAAU,CAAA;IACtB,cAAc,CAAC,EAAE,sBAAsB,CAAA;CACxC,GAAG,QAAQ,CASX;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CA0DtE,CAAA;AAEJ,wBAAgB,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAAE,CAiDnD"}

package/types/Ledger/TxOutputDatum.d.ts

@@ -0,0 +1,41 @@
+import { Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import * as Cbor from "../Cbor.js";
+import { Data } from "../Uplc";
+export declare const TxOutputDatum: Schema.Union<[Schema.TaggedStruct<"Inline", {
+    data: 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.TaggedStruct<"Hash", {
+    hash: Schema.brand<Schema.filter<typeof Schema.String>, "DatumHash">;
+}>]>;
+export type TxOutputDatum = Schema.Schema.Type<typeof TxOutputDatum>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeEffect<TxOutputDatum>;
+export declare function encode(txOutputDatum: TxOutputDatum): number[];
+//# sourceMappingURL=TxOutputDatum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TxOutputDatum.d.ts","sourceRoot":"","sources":["../../src/Ledger/TxOutputDatum.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,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAG9B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGzB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAA;AAEpE,eAAO,MAAM,MAAM,GACjB,OAAO,KAAK,CAAC,SAAS,KACrB,IAAI,CAAC,YAAY,CAAC,aAAa,CA+B9B,CAAA;AAEJ,wBAAgB,MAAM,CAAC,aAAa,EAAE,aAAa,GAAG,MAAM,EAAE,CAe7D"}

package/types/Ledger/TxOutputId.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import * as Cbor from "../Cbor.js";
+import * as TxId from "./TxId.js";
+export declare function isValid(txOutputId: string): txOutputId is TxOutputId;
+export declare const TxOutputId: Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "TxOutputId">>;
+export type TxOutputId = Schema.Schema.Type<typeof TxOutputId>;
+export declare function make(txId: TxId.TxId, utxoIdx: number | bigint): TxOutputId;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeEffect<TxOutputId>;
+export declare function encode(txOutputId: TxOutputId): number[];
+export declare function pretty(txOutputId: TxOutputId): string;
+export declare function txId(txOutputId: TxOutputId): TxId.TxId;
+export declare function utxoIdx(txOutputId: TxOutputId): number;
+//# sourceMappingURL=TxOutputId.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TxOutputId.d.ts","sourceRoot":"","sources":["../../src/Ledger/TxOutputId.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,WAAW,CAAA;AAEjC,wBAAgB,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,IAAI,UAAU,CAcpE;AAED,eAAO,MAAM,UAAU,yGAWtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9D,wBAAgB,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,CAE1E;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAGzE,CAAA;AAEH,wBAAgB,MAAM,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,EAAE,CAKvD;AAED,wBAAgB,MAAM,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAErD;AAED,wBAAgB,IAAI,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC,IAAI,CAEtD;AAED,wBAAgB,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAEtD"}

package/types/Ledger/ValidatorHash.d.ts

@@ -0,0 +1,40 @@
+import { Effect, Schema } from "effect";
+import * as Bytes from "../internal/Bytes.js";
+import { DecodeEffect } from "../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 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>, typeof Schema.Uint8ArrayFromSelf, never>, Schema.brand<Schema.filter<typeof Schema.String>, "ValidatorHash">>;
+export declare const decode: (bytes: Bytes.BytesLike) => DecodeEffect<ValidatorHash>;
+export declare function encode(vh: ValidatorHash): number[];
+//# sourceMappingURL=ValidatorHash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValidatorHash.d.ts","sourceRoot":"","sources":["../../src/Ledger/ValidatorHash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAe,YAAY,EAAe,MAAM,YAAY,CAAA;AACnE,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,yHAE1C;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/index.d.ts

@@ -0,0 +1,16 @@
+export * as Address from "./Address.js";
+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 TxOutput from "./TxOutput.js";
+export * as TxOutputDatum from "./TxOutputDatum.js";
+export * as TxOutputId from "./TxOutputId.js";
+export * as ValidatorHash from "./ValidatorHash.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}