@helios-lang/effect 0.1.14 → 0.2.0

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"}

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

@@ -0,0 +1,60 @@
+import { Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import * as Cbor from "../../Codecs/Cbor.js";
+import { IsMainnet } from "../Network/IsMainnet.js";
+import * as Data from "../Uplc/Data.js";
+import * as Credential from "./Credential.js";
+export declare function isValid(addr: string): boolean;
+export declare const RewardAddress: Schema.brand<Schema.filter<typeof Schema.String>, "RewardAddress">;
+export type RewardAddress = Schema.Schema.Type<typeof RewardAddress>;
+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>, Schema.Struct<{
+    credential: 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">;
+    }>]>>;
+}>, never>, Schema.SchemaClass<string & import("effect/Brand").Brand<"RewardAddress">, string & import("effect/Brand").Brand<"RewardAddress">, never>, IsMainnet>;
+export declare function make(isMainnet: boolean, cred: Credential.Credential): RewardAddress;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<RewardAddress>;
+export declare function encode(addr: RewardAddress): number[];
+export declare function bytes(address: RewardAddress): number[];
+export declare function isMainnet(address: RewardAddress): boolean;
+export declare function credential(address: RewardAddress): Credential.Credential;
+export declare function compare(a: RewardAddress, b: RewardAddress): number;
+//# sourceMappingURL=RewardAddress.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RewardAddress.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/RewardAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC5D,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAA;AAE9C,OAAO,KAAK,IAAI,MAAM,sBAAsB,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAI7C,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAM7C;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iKAYxB,CAAA;AAED,wBAAgB,IAAI,CAClB,SAAS,EAAE,OAAO,EAClB,IAAI,EAAE,UAAU,CAAC,UAAU,GAC1B,aAAa,CAKf;AAqDD,eAAO,MAAM,MAAM,GACjB,OAAO,KAAK,CAAC,SAAS,KACrB,IAAI,CAAC,YAAY,CAAC,aAAa,CAa/B,CAAA;AAEH,wBAAgB,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,EAAE,CAEpD;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,EAAE,CAEtD;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAEzD;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,UAAU,CAAC,UAAU,CAExE;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,MAAM,CAElE"}

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

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import { DecodeResult } from "../../Codecs/Cbor.js";
+export declare const Signature: Schema.Struct<{
+    pubKey: Schema.brand<Schema.filter<typeof Schema.String>, "PubKey">;
+    bytes: Schema.Schema<Uint8Array<ArrayBufferLike>, string, never>;
+}>;
+export type Signature = Schema.Schema.Type<typeof Signature>;
+export declare const decode: (bytes: Bytes.BytesLike) => DecodeResult<Signature>;
+export declare function encode(s: Signature): number[];
+export declare const dummy: Signature;
+export declare function isDummy(s: Signature): boolean;
+//# sourceMappingURL=Signature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Signature.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/Signature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAA;AAC9C,OAAO,EAEL,YAAY,EAIb,MAAM,sBAAsB,CAAA;AAG7B,eAAO,MAAM,SAAS;;;EAGpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,CAAA;AAE5D,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,YAAY,CAAC,SAAS,CAMnE,CAAA;AAEH,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,EAAE,CAE7C;AAED,eAAO,MAAM,KAAK,EAAE,SAGnB,CAAA;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAE7C"}