@helios-lang/effect 0.1.14 → 0.2.0

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

@@ -0,0 +1,375 @@
+import { Effect } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import * as Cbor from "../../Codecs/Cbor.js";
+import * as Params from "../Network/Params.js";
+import { Data, Script } from "../Uplc";
+import * as Assets from "./Assets.js";
+import * as DCert from "./DCert.js";
+import * as NativeScript from "./NativeScript.js";
+import * as PubKeyHash from "./PubKeyHash.js";
+import * as Redeemer from "./Redeemer.js";
+import * as RewardAddress from "./RewardAddress.js";
+import * as Signature from "./Signature.js";
+import * as TxHash from "./TxHash.js";
+import * as TxOutput from "./TxOutput.js";
+import * as UTxO from "./UTxO.js";
+/**
+ * Schemas don't make much sense here, because txs will only be (de)serialized using CBOR
+ */
+export interface Tx {
+    readonly body: Body;
+    readonly witnesses: Witnesses;
+    readonly metadata?: Metadata | undefined;
+    /**
+     * TODO: should this be generalized to "Unbalanced" | "Balanced" | "Valid" ?
+     */
+    readonly isValid: boolean;
+}
+export interface Body {
+    readonly inputs: readonly UTxO.UTxO[];
+    readonly outputs: readonly TxOutput.TxOutput[];
+    readonly fee: bigint;
+    readonly firstValidSlot?: number | undefined;
+    readonly lastValidSlot?: number | undefined;
+    readonly dcerts: readonly DCert.DCert[];
+    readonly withdrawals: readonly [RewardAddress.RewardAddress, bigint][];
+    readonly minted: Assets.Assets;
+    readonly scriptDataHash?: readonly number[] | undefined;
+    readonly collateral: readonly UTxO.UTxO[];
+    readonly signers: readonly PubKeyHash.PubKeyHash[];
+    readonly collateralReturn?: TxOutput.TxOutput | undefined;
+    readonly totalCollateral: bigint;
+    readonly refInputs: readonly UTxO.UTxO[];
+    readonly metadataHash?: readonly number[] | undefined;
+    readonly encoding?: BodyEncoding | undefined;
+}
+export interface BodyEncoding {
+    /**
+     * Defaults to true
+     */
+    inputsAsSet?: boolean | undefined;
+    /**
+     * Defaults to true
+     */
+    dcertsAsSet?: boolean | undefined;
+    /**
+     * Defaults to true
+     */
+    collateralInputsAsSet?: boolean | undefined;
+    /**
+     * Defaults to true
+     */
+    signersAsSet?: boolean | undefined;
+    /**
+     * Defaults to true
+     */
+    refInputsAsSet?: boolean | undefined;
+}
+export interface Witnesses {
+    readonly signatures: readonly Signature.Signature[];
+    readonly datums: readonly Data.Data[];
+    readonly redeemers: readonly Redeemer.Redeemer[];
+    readonly nativeScripts: readonly NativeScript.NativeScript[];
+    readonly v1Scripts: readonly Script.Script<1>[];
+    readonly v2Scripts: readonly Script.Script<2>[];
+    readonly v3Scripts: readonly Script.Script<3>[];
+    readonly v2RefScripts: readonly Script.Script<2>[];
+    readonly v3RefScripts: readonly Script.Script<3>[];
+    readonly encoding?: WitnessesEncoding | undefined;
+}
+export interface WitnessesEncoding {
+    /**
+     * Defaults to true
+     */
+    signaturesAsSet?: boolean | undefined;
+    /**
+     * Defaults to true
+     */
+    datumsAsSet?: boolean | undefined;
+    /**
+     * Defaults to true
+     */
+    nativeScriptsAsSet?: boolean | undefined;
+    /**
+     * Defaults to true
+     */
+    v1ScriptsAsSet?: boolean | undefined;
+    /**
+     * Defaults to true
+     */
+    v2ScriptsAsSet?: boolean | undefined;
+    /**
+     * Defaults to true
+     */
+    v3ScriptsAsSet?: boolean | undefined;
+}
+export type Metadata = Record<number, MetadataAttr>;
+export type MetadataAttr = string | number | readonly MetadataAttr[] | Readonly<{
+    [key: string]: MetadataAttr;
+}>;
+/**
+ * Used as a starting point for tx building
+ */
+export declare const empty: Tx;
+export declare const decode: (options?: {
+    trusted?: boolean;
+}) => (bytes: Bytes.BytesLike) => Effect.Effect<{
+    body: {
+        inputs: {
+            readonly ref: string & import("effect/Brand").Brand<"UTxORef">;
+            readonly output: {
+                readonly address: string & import("effect/Brand").Brand<"Address">;
+                readonly assets: {
+                    readonly [x: string]: bigint;
+                };
+                readonly datum?: {
+                    readonly _tag: "Inline";
+                    readonly data: {
+                        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 _tag: "Hash";
+                    readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+                } | undefined;
+                readonly refScript?: ({
+                    readonly root: Uint8Array<ArrayBufferLike>;
+                    readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+                } & {
+                    readonly version: 2;
+                }) | ({
+                    readonly root: Uint8Array<ArrayBufferLike>;
+                    readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+                } & {
+                    readonly version: 3;
+                }) | undefined;
+                readonly encodingConfig?: {
+                    readonly strictBabbage?: boolean | undefined;
+                } | undefined;
+            };
+        }[];
+        collateral: {
+            readonly ref: string & import("effect/Brand").Brand<"UTxORef">;
+            readonly output: {
+                readonly address: string & import("effect/Brand").Brand<"Address">;
+                readonly assets: {
+                    readonly [x: string]: bigint;
+                };
+                readonly datum?: {
+                    readonly _tag: "Inline";
+                    readonly data: {
+                        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 _tag: "Hash";
+                    readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+                } | undefined;
+                readonly refScript?: ({
+                    readonly root: Uint8Array<ArrayBufferLike>;
+                    readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+                } & {
+                    readonly version: 2;
+                }) | ({
+                    readonly root: Uint8Array<ArrayBufferLike>;
+                    readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+                } & {
+                    readonly version: 3;
+                }) | undefined;
+                readonly encodingConfig?: {
+                    readonly strictBabbage?: boolean | undefined;
+                } | undefined;
+            };
+        }[];
+        refInputs: {
+            readonly ref: string & import("effect/Brand").Brand<"UTxORef">;
+            readonly output: {
+                readonly address: string & import("effect/Brand").Brand<"Address">;
+                readonly assets: {
+                    readonly [x: string]: bigint;
+                };
+                readonly datum?: {
+                    readonly _tag: "Inline";
+                    readonly data: {
+                        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 _tag: "Hash";
+                    readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+                } | undefined;
+                readonly refScript?: ({
+                    readonly root: Uint8Array<ArrayBufferLike>;
+                    readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+                } & {
+                    readonly version: 2;
+                }) | ({
+                    readonly root: Uint8Array<ArrayBufferLike>;
+                    readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+                } & {
+                    readonly version: 3;
+                }) | undefined;
+                readonly encodingConfig?: {
+                    readonly strictBabbage?: boolean | undefined;
+                } | undefined;
+            };
+        }[];
+        outputs: {
+            readonly address: string & import("effect/Brand").Brand<"Address">;
+            readonly assets: {
+                readonly [x: string]: bigint;
+            };
+            readonly datum?: {
+                readonly _tag: "Inline";
+                readonly data: {
+                    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 _tag: "Hash";
+                readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+            } | undefined;
+            readonly refScript?: ({
+                readonly root: Uint8Array<ArrayBufferLike>;
+                readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+            } & {
+                readonly version: 2;
+            }) | ({
+                readonly root: Uint8Array<ArrayBufferLike>;
+                readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+            } & {
+                readonly version: 3;
+            }) | undefined;
+            readonly encodingConfig?: {
+                readonly strictBabbage?: boolean | undefined;
+            } | undefined;
+        }[];
+        fee: bigint;
+        firstValidSlot: number | undefined;
+        lastValidSlot: number | undefined;
+        dcerts: DCert.DCert[];
+        withdrawals: [string & import("effect/Brand").Brand<"RewardAddress">, bigint][];
+        metadataHash: number[] | undefined;
+        minted: {
+            readonly [x: string]: bigint;
+        };
+        scriptDataHash: number[] | undefined;
+        signers: (string & import("effect/Brand").Brand<"PubKeyHash">)[];
+        collateralReturn: {
+            readonly address: string & import("effect/Brand").Brand<"Address">;
+            readonly assets: {
+                readonly [x: string]: bigint;
+            };
+            readonly datum?: {
+                readonly _tag: "Inline";
+                readonly data: {
+                    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 _tag: "Hash";
+                readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+            } | undefined;
+            readonly refScript?: ({
+                readonly root: Uint8Array<ArrayBufferLike>;
+                readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+            } & {
+                readonly version: 2;
+            }) | ({
+                readonly root: Uint8Array<ArrayBufferLike>;
+                readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+            } & {
+                readonly version: 3;
+            }) | undefined;
+            readonly encodingConfig?: {
+                readonly strictBabbage?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        totalCollateral: bigint;
+        encoding: {
+            inputsAsSet: boolean;
+            dcertsAsSet: boolean;
+            collateralInputsAsSet: boolean;
+            signersAsSet: boolean;
+            refInputsAsSet: boolean;
+        };
+    };
+    witnesses: Witnesses;
+    isValid: boolean;
+    metadata: Metadata | undefined;
+}, Bytes.EndOfStreamError | Cbor.DecodeError | import("../Network/errors.js").ConnectionError | import("../Network/errors.js").UnexpectedFormat | import("../Network/errors.js").UTxONotFound | import("../Network/errors.js").UTxOAlreadySpent, import("../Network/UTxO.js").UTxO>;
+export declare const encode: (options?: {
+    forFeeCalculation?: boolean;
+    full?: boolean;
+}) => (tx: Tx) => number[];
+export declare function hashMetadata(metadata: Metadata): number[];
+export declare function hash(tx: Tx): TxHash.TxHash;
+/**
+ * Number of bytes of CBOR encoding of Tx
+ *
+ * Is used for two things:
+ *   - tx fee calculation
+ *   - tx size validation
+ *
+ * @param forFeeCalc
+ */
+export declare const size: (forFeeCalculation?: boolean) => (tx: Tx) => number;
+export declare const minFee: (tx: Tx) => Effect.Effect<bigint, never, Params.params>;
+export declare const inputDatum: (inputIndex: number) => (tx: Tx) => Data.Data | undefined;
+export declare const scriptDataHash: (tx: Tx) => Effect.Effect<number[] | undefined, never, Params.params>;
+//# sourceMappingURL=Tx.d.ts.map

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

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

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

@@ -1,6 +1,6 @@
-import { Effect, Schema } from "effect";
-import * as Bytes from "../internal/Bytes.js";
-import * as Cbor from "../Cbor.js";
+import { Either, Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import * as Cbor from "../../Codecs/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">;
@@ -64,7 +64,37 @@ export declare const FromUplcData: Schema.transform<Schema.transformOrFail<Schem
         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 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>, typeof Schema.String, never>, Schema.brand<Schema.filter<typeof Schema.String>, "TxHash">>;
+export declare function make(txId: Bytes.BytesLike): Either.Either<string & import("effect/Brand").Brand<"TxHash">, import("effect/ParseResult").ParseError>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<TxHash>;
 export declare function encode(txId: TxHash): number[];
+export declare function compare(a: TxHash, b: TxHash): number;
 //# sourceMappingURL=TxHash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TxHash.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/TxHash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAA;AAC9C,OAAO,KAAK,IAAI,MAAM,sBAAsB,CAAA;AAC5C,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,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;qGAIzB,CAAA;AAEF,wBAAgB,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,2GAEzC;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAUrE,CAAA;AAEH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAE7C;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEpD"}