@helios-lang/effect 0.1.15 → 0.3.0

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

@@ -1,15 +1,17 @@
 import { Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import * as Cbor from "../../Codecs/Cbor.js";
 import { Data } from "../Uplc";
-import { PubKeyHash } from "./PubKeyHash.js";
-import { ValidatorHash } from "./ValidatorHash.js";
+import * as PubKeyHash from "./PubKeyHash.js";
+import * as 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 function makePubKey(pkh: PubKeyHash.PubKeyHash): Credential;
+export declare function makeValidator(vh: ValidatorHash.ValidatorHash): Credential;
 export declare const FromUplcData: Schema.transform<Schema.Schema<({
     _tag: "PubKey";
 } & {
@@ -23,4 +25,8 @@ export declare const FromUplcData: Schema.transform<Schema.Schema<({
 }>, Schema.TaggedStruct<"Validator", {
     hash: Schema.brand<Schema.filter<typeof Schema.String>, "ValidatorHash">;
 }>]>>;
+export declare function bytes(cred: Credential): Uint8Array;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<Credential>;
+export declare function encode(cred: Credential): number[];
+export declare function equals(a: Credential, b: Credential): boolean;
 //# sourceMappingURL=Credential.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Credential.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/Credential.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,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,SAAS,CAAA;AAC9B,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD,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,CAAC,UAAU,GAAG,UAAU,CAEjE;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,aAAa,CAAC,aAAa,GAAG,UAAU,CAEzE;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;KAQxB,CAAA;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAElD;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAuBxE,CAAA;AAEJ,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAUjD;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAE5D"}

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

@@ -0,0 +1,40 @@
+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 Credential from "./Credential.js";
+import * as PubKeyHash from "./PubKeyHash.js";
+import * as ValidatorHash from "./ValidatorHash.js";
+export type Registration = {
+    _tag: "Registration";
+    credential: Credential.Credential;
+};
+export type Deregistration = {
+    _tag: "Deregistration";
+    credential: Credential.Credential;
+};
+export type Delegation = {
+    _tag: "Delegation";
+    credential: Credential.Credential;
+    poolId: PubKeyHash.PubKeyHash;
+};
+export type RegisterPool = {
+    _tag: "RegisterPool";
+    id: PubKeyHash.PubKeyHash;
+    vrf: PubKeyHash.PubKeyHash;
+    pledge: bigint;
+    margin: number;
+    owners: readonly PubKeyHash.PubKeyHash[];
+};
+export type RetirePool = {
+    _tag: "RetirePool";
+    poolId: PubKeyHash.PubKeyHash;
+    epoch: number;
+};
+export type DCert = Registration | Deregistration | Delegation | RegisterPool | RetirePool;
+export declare const FromUplcData: Schema.Schema<DCert, Data.Data>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<DCert>;
+export declare function encode(dcert: DCert): number[];
+export declare function equals(a: DCert, b: DCert): boolean;
+export declare function validatorHash(dcert: DCert): ValidatorHash.ValidatorHash;
+//# sourceMappingURL=DCert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DCert.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/DCert.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,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,cAAc,CAAA;IACpB,UAAU,EAAE,UAAU,CAAC,UAAU,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,gBAAgB,CAAA;IACtB,UAAU,EAAE,UAAU,CAAC,UAAU,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,YAAY,CAAA;IAClB,UAAU,EAAE,UAAU,CAAC,UAAU,CAAA;IACjC,MAAM,EAAE,UAAU,CAAC,UAAU,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,cAAc,CAAA;IACpB,EAAE,EAAE,UAAU,CAAC,UAAU,CAAA;IACzB,GAAG,EAAE,UAAU,CAAC,UAAU,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IAEd,MAAM,EAAE,SAAS,UAAU,CAAC,UAAU,EAAE,CAAA;CAGzC,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,YAAY,CAAA;IAClB,MAAM,EAAE,UAAU,CAAC,UAAU,CAAA;IAC7B,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,KAAK,GACb,YAAY,GACZ,cAAc,GACd,UAAU,GACV,YAAY,GACZ,UAAU,CAAA;AAEd,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAsBvD,CAAA;AAEF,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CA4BnE,CAAA;AAEJ,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,EAAE,CA2B7C;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO,CAelD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,CAAC,aAAa,CAcvE"}

package/types/{Ledger → Cardano/Ledger}/DatumHash.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(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 function make(bytes: Bytes.BytesLike): Either.Either<string & import("effect/Brand").Brand<"DatumHash">, import("effect/ParseResult").ParseError>;
 export declare const FromUplcData: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
     readonly bytes: Uint8Array<ArrayBufferLike>;
 } | {
@@ -35,6 +35,7 @@ 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>, "DatumHash">>;
-export declare const decode: (bytes: Bytes.BytesLike) => DecodeEffect<DatumHash>;
+export declare const decode: (bytes: Bytes.BytesLike) => DecodeResult<DatumHash>;
 export declare function encode(dh: DatumHash): number[];
+export declare function hash(d: Data.Data): DatumHash;
 //# sourceMappingURL=DatumHash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DatumHash.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/DatumHash.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;AAE7E,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,8GAE1C;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;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,GAAG,SAAS,CAI5C"}

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

@@ -1,8 +1,10 @@
-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">>;
+import { Either, 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 ValidatorHash from "./ValidatorHash.js";
+export declare function isValid(mph: string): mph is MintingPolicy;
+export declare const MintingPolicy: Schema.brand<Schema.filter<typeof Schema.String>, "MintingPolicy">;
 export type MintingPolicy = Schema.Schema.Type<typeof MintingPolicy>;
 export declare const FromUplcData: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
     readonly bytes: Uint8Array<ArrayBufferLike>;
@@ -32,8 +34,9 @@ export declare const FromUplcData: Schema.transform<Schema.transformOrFail<Schem
 } | {
     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>;
+}, never>, typeof Schema.Uint8ArrayFromSelf, never>, Schema.brand<Schema.filter<typeof Schema.String>, "MintingPolicy">>;
+export declare function make(policy: Bytes.BytesLike): Either.Either<string & import("effect/Brand").Brand<"MintingPolicy">, import("effect/ParseResult").ParseError>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<MintingPolicy>;
 export declare function encode(policy: MintingPolicy): number[];
+export declare function hash(policy: MintingPolicy): ValidatorHash.ValidatorHash;
 //# sourceMappingURL=MintingPolicy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MintingPolicy.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/MintingPolicy.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,KAAK,IAAI,MAAM,iBAAiB,CAAA;AACvC,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,aAAa,CAQzD;AAED,eAAO,MAAM,aAAa,oEAKzB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAA;AAEpE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;wHAIvB,CAAA;AAEF,wBAAgB,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,kHAE3C;AAED,eAAO,MAAM,MAAM,GACjB,OAAO,KAAK,CAAC,SAAS,KACrB,IAAI,CAAC,YAAY,CAAC,aAAa,CAU/B,CAAA;AAEH,wBAAgB,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,EAAE,CAEtD;AAED,wBAAgB,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa,CAAC,aAAa,CAMvE"}

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

@@ -0,0 +1,105 @@
+import { Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import * as Cbor from "../../Codecs/Cbor.js";
+import * as PubKeyHash from "./PubKeyHash.js";
+import * as ValidatorHash from "./ValidatorHash.js";
+export declare const After: Schema.Struct<{
+    type: Schema.Literal<["after"]>;
+    slot: typeof Schema.Number;
+}>;
+export type After = Schema.Schema.Type<typeof After>;
+export declare const Before: Schema.Struct<{
+    type: Schema.Literal<["before"]>;
+    slot: typeof Schema.Number;
+}>;
+export type Before = Schema.Schema.Type<typeof Before>;
+export declare const All: Schema.Struct<{
+    type: Schema.Literal<["all"]>;
+    scripts: Schema.Array$<Schema.suspend<NativeScript, NativeScriptJSON, never>>;
+}>;
+export type All = Schema.Schema.Type<typeof All>;
+export declare const Any: Schema.Struct<{
+    type: Schema.Literal<["any"]>;
+    scripts: Schema.Array$<Schema.suspend<NativeScript, NativeScriptJSON, never>>;
+}>;
+export type Any = Schema.Schema.Type<typeof Any>;
+export declare const AtLeast: Schema.Struct<{
+    type: Schema.Literal<["atLeast"]>;
+    required: typeof Schema.Number;
+    scripts: Schema.Array$<Schema.suspend<NativeScript, NativeScriptJSON, never>>;
+}>;
+export type AtLeast = Schema.Schema.Type<typeof AtLeast>;
+export declare const Sig: Schema.Struct<{
+    type: Schema.Literal<["sig"]>;
+    keyHash: Schema.brand<Schema.filter<typeof Schema.String>, "PubKeyHash">;
+}>;
+export type Sig = Schema.Schema.Type<typeof Sig>;
+export type NativeScript = {
+    type: "after";
+    slot: number;
+} | {
+    type: "before";
+    slot: number;
+} | {
+    type: "all";
+    scripts: readonly NativeScript[];
+} | {
+    type: "any";
+    scripts: readonly NativeScript[];
+} | {
+    type: "atLeast";
+    required: number;
+    scripts: readonly NativeScript[];
+} | {
+    type: "sig";
+    keyHash: PubKeyHash.PubKeyHash;
+};
+export type NativeScriptJSON = {
+    type: "after";
+    slot: number;
+} | {
+    type: "before";
+    slot: number;
+} | {
+    type: "all";
+    scripts: readonly NativeScriptJSON[];
+} | {
+    type: "any";
+    scripts: readonly NativeScriptJSON[];
+} | {
+    type: "atLeast";
+    required: number;
+    scripts: readonly NativeScriptJSON[];
+} | {
+    type: "sig";
+    keyHash: string;
+};
+export declare const NativeScript: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["after"]>;
+    slot: typeof Schema.Number;
+}>, Schema.Struct<{
+    type: Schema.Literal<["before"]>;
+    slot: typeof Schema.Number;
+}>, Schema.Struct<{
+    type: Schema.Literal<["all"]>;
+    scripts: Schema.Array$<Schema.suspend<NativeScript, NativeScriptJSON, never>>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["any"]>;
+    scripts: Schema.Array$<Schema.suspend<NativeScript, NativeScriptJSON, never>>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["atLeast"]>;
+    required: typeof Schema.Number;
+    scripts: Schema.Array$<Schema.suspend<NativeScript, NativeScriptJSON, never>>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["sig"]>;
+    keyHash: Schema.brand<Schema.filter<typeof Schema.String>, "PubKeyHash">;
+}>]>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<NativeScript>;
+export declare function encode(script: NativeScript): number[];
+export declare function hash(script: NativeScript): ValidatorHash.ValidatorHash;
+export declare function validate(ctx: {
+    firstValidSlot?: number;
+    lastValidSlot?: number;
+    signers: PubKeyHash.PubKeyHash[];
+}): (script: NativeScript) => boolean;
+//# sourceMappingURL=NativeScript.d.ts.map

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

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

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

@@ -0,0 +1,45 @@
+import { Either, Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import { DecodeResult } from "../../Codecs/Cbor.js";
+import * as Bip32 from "../../Crypto/Bip32.js";
+import { Data } from "../Uplc";
+import type { PubKeyHash } from "./PubKeyHash.js";
+export declare const isValid: typeof Bip32.isValidVerificationKey;
+export declare const PubKey: Schema.brand<Schema.filter<typeof Schema.String>, "Crypto.Bip32.VerificationKey">;
+export type PubKey = Bip32.VerificationKey;
+export declare const make: (bytes: Bytes.BytesLike) => Either.Either<Bip32.VerificationKey, import("effect/ParseResult").Unexpected>;
+export declare const FromUplcData: Schema.transformOrFail<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.SchemaClass<string & import("effect/Brand").Brand<"Crypto.Bip32.VerificationKey">, string & import("effect/Brand").Brand<"Crypto.Bip32.VerificationKey">, never>, never>;
+export declare const decode: (bytes: Bytes.BytesLike) => DecodeResult<PubKey>;
+export declare const bytes: (vk: Bip32.VerificationKey) => Uint8Array;
+export declare function encode(pkh: PubKey): number[];
+export declare const dummy: PubKey;
+export declare function hash(pk: PubKey): PubKeyHash;
+//# sourceMappingURL=PubKey.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PubKey.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/PubKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAY,MAAM,EAAE,MAAM,QAAQ,CAAA;AACzD,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAA;AAC9C,OAAO,EAGL,YAAY,EAEb,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAA;AAE9C,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,eAAO,MAAM,OAAO,qCAA+B,CAAA;AAEnD,eAAO,MAAM,MAAM,mFAAwB,CAAA;AAC3C,MAAM,MAAM,MAAM,GAAG,KAAK,CAAC,eAAe,CAAA;AAE1C,eAAO,MAAM,IAAI,2GAA4B,CAAA;AAE7C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;oOAQxB,CAAA;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,YAAY,CAAC,MAAM,CAOhE,CAAA;AAEH,eAAO,MAAM,KAAK,2CAAgB,CAAA;AAElC,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAE5C;AAED,eAAO,MAAM,KAAK,EAAE,MAET,CAAA;AAEX,wBAAgB,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,CAE3C"}

package/types/{Ledger → Cardano/Ledger}/PubKeyHash.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(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 function make(bytes: Bytes.BytesLike): Either.Either<string & import("effect/Brand").Brand<"PubKeyHash">, 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>, "PubKeyHash">>;
-export declare const decode: (bytes: Bytes.BytesLike) => DecodeEffect<PubKeyHash>;
+export declare const decode: (bytes: Bytes.BytesLike) => DecodeResult<PubKeyHash>;
 export declare function encode(pkh: PubKeyHash): number[];
 //# sourceMappingURL=PubKeyHash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PubKeyHash.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/PubKeyHash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAY,MAAM,EAAE,MAAM,QAAQ,CAAA;AACzD,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,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,+GAE1C;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/Cardano/Ledger/Redeemer.d.ts

@@ -0,0 +1,303 @@
+import { Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import * as Cbor from "../../Codecs/Cbor.js";
+import { Data } from "../Uplc";
+export declare const Minting: Schema.TaggedStruct<"Minting", {
+    policyIndex: typeof Schema.Number;
+    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>;
+    cost: Schema.Struct<{
+        cpu: typeof Schema.BigIntFromSelf;
+        mem: typeof Schema.BigIntFromSelf;
+    }>;
+}>;
+export type Minting = Schema.Schema.Type<typeof Minting>;
+export declare const Spending: Schema.TaggedStruct<"Spending", {
+    inputIndex: typeof Schema.Number;
+    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>;
+    cost: Schema.Struct<{
+        cpu: typeof Schema.BigIntFromSelf;
+        mem: typeof Schema.BigIntFromSelf;
+    }>;
+}>;
+export type Spending = Schema.Schema.Type<typeof Spending>;
+export declare const Rewarding: Schema.TaggedStruct<"Rewarding", {
+    withdrawalIndex: typeof Schema.Number;
+    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>;
+    cost: Schema.Struct<{
+        cpu: typeof Schema.BigIntFromSelf;
+        mem: typeof Schema.BigIntFromSelf;
+    }>;
+}>;
+export type Rewarding = Schema.Schema.Type<typeof Rewarding>;
+export declare const Certifying: Schema.TaggedStruct<"Certifying", {
+    dcertIndex: typeof Schema.Number;
+    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>;
+    cost: Schema.Struct<{
+        cpu: typeof Schema.BigIntFromSelf;
+        mem: typeof Schema.BigIntFromSelf;
+    }>;
+}>;
+export type Certifying = Schema.Schema.Type<typeof Certifying>;
+export declare const Redeemer: Schema.Union<[Schema.TaggedStruct<"Minting", {
+    policyIndex: typeof Schema.Number;
+    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>;
+    cost: Schema.Struct<{
+        cpu: typeof Schema.BigIntFromSelf;
+        mem: typeof Schema.BigIntFromSelf;
+    }>;
+}>, Schema.TaggedStruct<"Spending", {
+    inputIndex: typeof Schema.Number;
+    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>;
+    cost: Schema.Struct<{
+        cpu: typeof Schema.BigIntFromSelf;
+        mem: typeof Schema.BigIntFromSelf;
+    }>;
+}>, Schema.TaggedStruct<"Rewarding", {
+    withdrawalIndex: typeof Schema.Number;
+    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>;
+    cost: Schema.Struct<{
+        cpu: typeof Schema.BigIntFromSelf;
+        mem: typeof Schema.BigIntFromSelf;
+    }>;
+}>, Schema.TaggedStruct<"Certifying", {
+    dcertIndex: typeof Schema.Number;
+    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>;
+    cost: Schema.Struct<{
+        cpu: typeof Schema.BigIntFromSelf;
+        mem: typeof Schema.BigIntFromSelf;
+    }>;
+}>]>;
+export type Redeemer = Schema.Schema.Type<typeof Redeemer>;
+/**
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function compare(a: Redeemer, b: Redeemer): number;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<Redeemer>;
+export declare function encode(redeemer: Redeemer): number[];
+//# sourceMappingURL=Redeemer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Redeemer.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/Redeemer.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,EAAQ,IAAI,EAAE,MAAM,SAAS,CAAA;AAEpC,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIlB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC,CAAA;AAExD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE1D,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,CAAA;AAE5D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIrB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAyD,CAAA;AAE9E,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE1D;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CA2DxD;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CA0CtE,CAAA;AAEJ,wBAAgB,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAAE,CA+BnD"}