@harmoniclabs/pebble 0.1.0-dev0

package/dist/compiler/tir/program/stdScope/stdScope.js

@@ -0,0 +1,730 @@
+import { TirAliasType } from "../../types/TirAliasType.js";
+import { TirDataStructType, TirSoPStructType, TirStructConstr, TirStructField } from "../../types/TirStructType.js";
+import { TirBoolT } from "../../types/TirNativeType/native/bool.js";
+import { TirBytesT } from "../../types/TirNativeType/native/bytes.js";
+import { TirDataT } from "../../types/TirNativeType/native/data.js";
+import { TirIntT } from "../../types/TirNativeType/native/int.js";
+import { TirLinearMapT } from "../../types/TirNativeType/native/linearMap.js";
+import { TirListT } from "../../types/TirNativeType/native/list.js";
+import { TirDataOptT } from "../../types/TirNativeType/native/Optional/data.js";
+import { TirSopOptT } from "../../types/TirNativeType/native/Optional/sop.js";
+import { TirStringT } from "../../types/TirNativeType/native/string.js";
+import { TirVoidT } from "../../types/TirNativeType/native/void.js";
+import { PEBBLE_INTERNAL_IDENTIFIER_PREFIX } from "../../../internalVar.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirInlineClosedIR } from "../../expressions/TirInlineClosedIR.js";
+import { TirFuncT } from "../../types/TirNativeType/index.js";
+import { IRNative } from "../../../../IR/IRNodes/IRNative/index.js";
+export const void_t = new TirVoidT();
+export const int_t = new TirIntT();
+export const string_t = new TirStringT();
+export const bytes_t = new TirBytesT();
+export const bool_t = new TirBoolT();
+export const data_t = new TirDataT();
+export function populateStdScope(program) {
+    const stdScope = program.stdScope;
+    function _defineStdUnambigous(t) {
+        const name = t.toTirTypeKey();
+        program.types.set(name, t);
+        stdScope.defineUnambigousType(name, name, true, new Map());
+    }
+    _defineStdUnambigous(void_t);
+    _defineStdUnambigous(bool_t);
+    _defineStdUnambigous(int_t);
+    _defineStdUnambigous(bytes_t);
+    _defineStdUnambigous(string_t);
+    _defineStdUnambigous(data_t);
+    const opt_data_name = TirDataOptT.toTirTypeKey();
+    program.defineGenericType(opt_data_name, 1, ([arg]) => new TirDataOptT(arg));
+    const opt_sop_name = TirSopOptT.toTirTypeKey();
+    program.defineGenericType(opt_sop_name, 1, ([arg]) => new TirSopOptT(arg));
+    const ast_opt_name = "Optional";
+    stdScope.defineType(ast_opt_name, {
+        sopTirName: opt_sop_name,
+        dataTirName: opt_data_name,
+        allTirNames: new Set([
+            opt_data_name,
+            opt_sop_name,
+        ]),
+        methodsNames: new Map(),
+        isGeneric: true
+    });
+    const list_name = TirListT.toTirTypeKey();
+    program.defineGenericType(list_name, 1, ([arg]) => new TirListT(arg));
+    stdScope.defineType(list_name, {
+        sopTirName: list_name,
+        dataTirName: list_name,
+        allTirNames: new Set([
+            list_name
+        ]),
+        methodsNames: new Map(),
+        isGeneric: true
+    });
+    const linearMap_name = TirLinearMapT.toTirTypeKey();
+    program.defineGenericType(linearMap_name, 2, ([arg1, arg2]) => new TirLinearMapT(arg1, arg2));
+    stdScope.defineType(linearMap_name, {
+        sopTirName: linearMap_name,
+        dataTirName: linearMap_name,
+        allTirNames: new Set([
+            linearMap_name
+        ]),
+        methodsNames: new Map(),
+        isGeneric: true
+    });
+    stdScope.readonly();
+}
+export function populatePreludeScope(program) {
+    const preludeScope = program.preludeScope;
+    // empty string will be never generated as uid,
+    // so it is fine to use it for prelude
+    const preludeFileUid = "";
+    const bytes_t = program.types.get(TirBytesT.toTirTypeKey());
+    const int_t = program.types.get(TirIntT.toTirTypeKey());
+    const data_t = program.types.get(TirDataT.toTirTypeKey());
+    const bool_t = program.types.get(TirBoolT.toTirTypeKey());
+    if (!(bytes_t
+        && int_t
+        && data_t
+        && bool_t))
+        throw new Error("stdScope uninitialized");
+    const map_int_data_t = program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [int_t.toConcreteTirTypeName(), data_t.toConcreteTirTypeName()]);
+    if (!(map_int_data_t))
+        throw new Error("stdScope uninitialized");
+    function _defineUnambigousAlias(name, tirType, methodsNames = new Map()) {
+        const t = new TirAliasType(name, preludeFileUid, tirType, methodsNames);
+        const tir_key = t.toTirTypeKey();
+        program.types.set(tir_key, t);
+        preludeScope.defineUnambigousType(name, tir_key, t.hasDataEncoding(), methodsNames);
+        return t;
+    }
+    const hash32_t = _defineUnambigousAlias("Hash32", bytes_t);
+    const hash28_t = _defineUnambigousAlias("Hash28", bytes_t);
+    const policyId_t = _defineUnambigousAlias("PolicyId", hash28_t);
+    const tokenName_t = _defineUnambigousAlias("TokenName", bytes_t);
+    const pubKeyHash_t = _defineUnambigousAlias("PubKeyHash", hash28_t);
+    const scriptHash_t = _defineUnambigousAlias("ScriptHash", hash28_t);
+    const txHash_t = _defineUnambigousAlias("TxHash", hash32_t);
+    function mkSingleConstructorStruct(name, fields, methodNames = new Map()) {
+        const sop = new TirSoPStructType(name, preludeFileUid, [
+            new TirStructConstr(name, Object.keys(fields).map(name => new TirStructField(name, fields[name])))
+        ], methodNames);
+        const data = new TirDataStructType(name, preludeFileUid, [
+            new TirStructConstr(name, Object.keys(fields).map(name => new TirStructField(name, fields[name])))
+        ], methodNames);
+        return { sop, data };
+    }
+    function defineSingleConstructorStruct(name, fields, opts, methodsNames = new Map()) {
+        const { sop, data } = mkSingleConstructorStruct(name, fields);
+        const sop_key = sop.toTirTypeKey();
+        const data_key = data.toTirTypeKey();
+        if (opts.sop)
+            program.types.set(sop_key, sop);
+        if (opts.data)
+            program.types.set(data_key, data);
+        preludeScope.defineType(name, {
+            sopTirName: sop_key,
+            dataTirName: opts.data ? data_key : undefined,
+            allTirNames: new Set([
+                sop_key,
+                opts.data ? data_key : undefined
+            ].filter(x => typeof x === "string")),
+            methodsNames,
+            isGeneric: false
+        });
+        return { sop, data };
+    }
+    function mkMultiConstructorStruct(name, constrs, methodNames = new Map()) {
+        const sop = new TirSoPStructType(name, preludeFileUid, Object.keys(constrs).map(constrName => new TirStructConstr(constrName, Object.keys(constrs[constrName]).map(name => new TirStructField(name, constrs[constrName][name])))), methodNames);
+        const data = new TirDataStructType(name, preludeFileUid, Object.keys(constrs).map(constrName => new TirStructConstr(constrName, Object.keys(constrs[constrName]).map(name => new TirStructField(name, constrs[constrName][name])))), methodNames);
+        return { sop, data };
+    }
+    function defineMultiConstructorStruct(name, constrs, opts, methodsNames = new Map()) {
+        const { sop, data } = mkMultiConstructorStruct(name, constrs);
+        const sop_key = sop.toTirTypeKey();
+        const data_key = data.toTirTypeKey();
+        if (opts.sop)
+            program.types.set(sop_key, sop);
+        if (opts.data)
+            program.types.set(data_key, data);
+        preludeScope.defineType(name, {
+            sopTirName: sop_key,
+            dataTirName: opts.data ? data_key : undefined,
+            allTirNames: new Set([
+                sop_key,
+                opts.data ? data_key : undefined
+            ].filter(x => typeof x === "string")),
+            methodsNames,
+            isGeneric: false
+        });
+        return { sop, data };
+    }
+    const onlyData = {
+        sop: false,
+        data: true
+    };
+    const { data: txOutRef_t } = defineSingleConstructorStruct("TxOutRef", {
+        id: txHash_t,
+        index: int_t
+    }, onlyData);
+    const { data: credential_t } = defineMultiConstructorStruct("Credential", {
+        PubKey: {
+            hash: pubKeyHash_t
+        },
+        Script: {
+            hash: scriptHash_t
+        }
+    }, onlyData);
+    // TODO: 
+    // understand how to describe function impls
+    // const credential_t_impl = new TirInterfaceType(
+    //     undefined,
+    //     [],
+    //     []
+    // )
+    // credential_t_impl.methods.push(
+    //     new TirInterfaceMethod(
+    //         credential_t_impl,
+    //         "hash",
+    //         [],
+    //         hash28_t
+    //     )
+    // );
+    // credential_t.impls.push(
+    //     new TirInterfaceImpl(
+    //         credential_t,
+    //         credential_t_impl
+    //     )
+    // );
+    const changeParams_t = _defineUnambigousAlias("ChangedParameters", map_int_data_t);
+    const { data: rational_t } = defineSingleConstructorStruct("Rational", {
+        numerator: int_t,
+        denominator: int_t
+    }, onlyData);
+    const { data: protocolVersion_t } = defineSingleConstructorStruct("ProtocolVersion", {
+        major: int_t,
+        minor: int_t
+    }, onlyData);
+    // struct ConstitutionInfo {
+    //     consitutionScriptHash: Optional<ScriptHash>
+    // }
+    const opt_scriptHash_t = program.getAppliedGeneric(TirDataOptT.toTirTypeKey(), [scriptHash_t]);
+    if (!opt_scriptHash_t)
+        throw new Error("expected opt_scriptHash_t");
+    const { data: constitutionInfo_t } = defineSingleConstructorStruct("ConstitutionInfo", {
+        consitutionScriptHash: opt_scriptHash_t
+    }, onlyData);
+    // struct GovAction {
+    //     ParameterChange {
+    //         govActionId: Optional<TxOutRef>,
+    //         changedParameters: ChangedParameters,
+    //         constitutionScriptHash: Optional<ScriptHash>
+    //     }
+    //     HardForkInitiation {
+    //         govActionId: Optional<TxOutRef>,
+    //         nextProtocolVersion: ProtocolVersion
+    //     }
+    //     TreasuryWithdrawals {
+    //         withdrawals: LinearMap<Credential, int>
+    //         constitutionScriptHash: Optional<ScriptHash>
+    //     }
+    //     NoConfidence {
+    //         govActionId: Optional<TxOutRef>
+    //     }
+    //     UpdateCommittee {
+    //         govActionId: Optional<TxOutRef>,
+    //         removed: List<Credential>,
+    //         newMembers: LinearMap<Credential, int>,
+    //         newQuorum: Rational
+    //     }
+    //     NewConstitution {
+    //         govActionId: Optional<TxOutRef>,
+    //         info: ConstitutionInfo
+    //     }
+    //     InfoAction {}
+    // }
+    const opt_txOutRef_t = program.getAppliedGeneric(TirDataOptT.toTirTypeKey(), [txOutRef_t]);
+    if (!opt_txOutRef_t)
+        throw new Error("expected opt_txOutRef_t");
+    const map_cred_int_t = program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [credential_t, int_t]);
+    if (!map_cred_int_t)
+        throw new Error("expected map_cred_int_t");
+    const list_cred_t = program.getAppliedGeneric(TirListT.toTirTypeKey(), [credential_t]);
+    if (!list_cred_t)
+        throw new Error("expected list_cred_t");
+    const { data: govAction_t } = defineMultiConstructorStruct("GovAction", {
+        ParameterChange: {
+            govActionId: opt_txOutRef_t,
+            changedParameters: map_int_data_t,
+            constitutionScriptHash: opt_scriptHash_t
+        },
+        HardForkInitiation: {
+            govActionId: opt_txOutRef_t,
+            nextProtocolVersion: protocolVersion_t
+        },
+        TreasuryWithdrawals: {
+            withdrawals: map_cred_int_t,
+            constitutionScriptHash: opt_scriptHash_t
+        },
+        NoConfidence: {
+            govActionId: opt_txOutRef_t
+        },
+        UpdateCommittee: {
+            govActionId: opt_txOutRef_t,
+            removed: list_cred_t,
+            newMembers: map_cred_int_t,
+            newQuorum: rational_t
+        },
+        NewConstitution: {
+            govActionId: opt_txOutRef_t,
+            info: constitutionInfo_t
+        },
+        InfoAction: {}
+    }, onlyData);
+    // struct ProposalProcedure {
+    //     deposit: int,
+    //     credential: Credential,
+    //     action: GovAction
+    // }
+    const { data: proposalProcedure_t } = defineSingleConstructorStruct("ProposalProcedure", {
+        deposit: int_t,
+        credential: credential_t,
+        action: govAction_t
+    }, onlyData);
+    // struct Voter {
+    //     Committee {
+    //         credential: Credential
+    //     }
+    //     DRep {
+    //         credential: Credential
+    //     }
+    //     StakePool {
+    //         credential: PubKeyHash
+    //     }
+    // }
+    const { data: voter_t } = defineMultiConstructorStruct("Voter", {
+        Committee: {
+            credential: credential_t
+        },
+        DRep: {
+            credential: credential_t
+        },
+        StakePool: {
+            pubKeyHash: pubKeyHash_t
+        }
+    }, onlyData);
+    // struct ScriptPurpose {
+    //     Mint { policy: PolicyId }
+    //     Spend {
+    //         ref: TxOutRef,
+    //     }
+    //     Withdraw {
+    //         credential: Credential
+    //     }
+    //     Certificate {
+    //         index: int,
+    //         certificate: Certificate
+    //     }
+    //     Vote {
+    //         voter: Voter
+    //     }
+    //     Propose {
+    //         index: int,
+    //         proposal: ProposalProcedure
+    //     }
+    // }
+    const { data: scriptPurpose_t } = defineMultiConstructorStruct("ScriptPurpose", {
+        Mint: {
+            policy: policyId_t
+        },
+        Spend: {
+            ref: txOutRef_t
+        },
+        Withdraw: {
+            credential: credential_t
+        },
+        Certificate: {
+            index: int_t,
+            certificate: credential_t
+        },
+        Vote: {
+            voter: voter_t
+        },
+        Propose: {
+            index: int_t,
+            proposal: proposalProcedure_t
+        }
+    }, onlyData);
+    // struct ScriptInfo {
+    //     Mint { policy: PolicyId }
+    //     Spend {
+    //         ref: TxOutRef,
+    //         datum: Optional<data>
+    //     }
+    //     Withdraw {
+    //         credential: Credential
+    //     }
+    //     Certificate {
+    //         index: int,
+    //         certificate: Certificate
+    //     }
+    //     Vote {
+    //         voter: Voter
+    //     }
+    //     Propose {
+    //         index: int,
+    //         proposal: ProposalProcedure
+    //     }
+    // }
+    const opt_data_t = program.getAppliedGeneric(TirDataOptT.toTirTypeKey(), [data_t]);
+    if (!opt_data_t)
+        throw new Error("expected opt_data_t");
+    const { data: scriptInfo_t } = defineMultiConstructorStruct("ScriptInfo", {
+        Mint: {
+            policy: policyId_t
+        },
+        Spend: {
+            ref: txOutRef_t,
+            optionalDatum: opt_data_t
+        },
+        Withdraw: {
+            credential: credential_t
+        },
+        Certificate: {
+            index: int_t,
+            certificate: credential_t
+        },
+        Vote: {
+            voter: voter_t
+        },
+        Propose: {
+            index: int_t,
+            proposal: proposalProcedure_t
+        }
+    }, onlyData);
+    // struct StakeCredential {
+    //     Credential { credential: Credential }
+    //     Ptr {
+    //        a: int,
+    //        b: int,
+    //        c: int
+    //     }
+    // }
+    const { data: stakeCredential_t } = defineMultiConstructorStruct("StakeCredential", {
+        Credential: {
+            credential: credential_t
+        },
+        Ptr: {
+            a: int_t,
+            b: int_t,
+            c: int_t
+        }
+    }, onlyData);
+    // struct Address {
+    //     payment: Credential,
+    //     stake: Optional<Credential>
+    // }
+    const opt_stakeCredential_t = program.getAppliedGeneric(TirDataOptT.toTirTypeKey(), [stakeCredential_t]);
+    if (!opt_stakeCredential_t)
+        throw new Error("expected opt_stakeCredential_t");
+    const { data: address_t } = defineSingleConstructorStruct("Address", {
+        payment: credential_t,
+        stake: opt_stakeCredential_t
+    }, onlyData);
+    // type Value = LinearMap<PolicyId, LinearMap<TokenName, int>>
+    const map_tokenName_int_t = program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [tokenName_t, int_t]);
+    if (!map_tokenName_int_t)
+        throw new Error("expected map_tokenName_int_t");
+    const map_policyId_map_tokenName_int_t = program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [policyId_t, map_tokenName_int_t]);
+    if (!map_policyId_map_tokenName_int_t)
+        throw new Error("expected map_policyId_map_tokenName_int_t");
+    const valueLovelacesName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "sortedValueLovelaces";
+    const value_t = _defineUnambigousAlias("Value", map_policyId_map_tokenName_int_t, new Map([
+        [
+            "lovelaces",
+            valueLovelacesName
+        ],
+    ]));
+    preludeScope.program.functions.set(valueLovelacesName, new TirInlineClosedIR(new TirFuncT([value_t], int_t), (ctx) => IRNative._sortedValueLovelaces, SourceRange.unknown));
+    /* // TODO
+    untagged struct FlatValueEntry {
+        policy: PolicyId,
+        name: bytes,
+        amount: int
+    }
+
+    type FlatValue = List<FlatValueEntry>;
+
+    type Value implements {
+        amountOf( policy: PolicyId, name: bytes ): int
+        {
+            return native.valueAmountOf( this, policy, name );
+        }
+        lovelaces(): int
+        {
+            return this.amountOf( #, # );
+        }
+        flatten(): FlatValue
+        {
+            return native.flattenValue( this );
+        }
+    }
+
+    type FlatValue implements {
+        unflatten(): Value
+        {
+            return native.unflattenValue( this );
+        }
+    }
+    */
+    // struct OutputDatum {
+    //     NoDatum {}
+    //     DatumHash { hash: Hash32 }
+    //     InlineDatum { datum: data }
+    // }
+    const { data: outputDatum_t } = defineMultiConstructorStruct("OutputDatum", {
+        NoDatum: {},
+        DatumHash: {
+            hash: hash32_t
+        },
+        InlineDatum: {
+            datum: data_t
+        }
+    }, onlyData);
+    const { data: txOut_t } = defineSingleConstructorStruct("TxOut", {
+        address: address_t,
+        value: value_t,
+        datum: outputDatum_t,
+        referenceScript: opt_scriptHash_t
+    }, onlyData);
+    // struct TxIn {
+    //     txOutRef: TxOutRef,
+    //     resolved: TxOut
+    // }
+    const { data: txIn_t } = defineSingleConstructorStruct("TxIn", {
+        txOutRef: txOutRef_t,
+        resolved: txOut_t
+    }, onlyData);
+    // struct ExtendedInteger {
+    //     NegInf {}
+    //     Finite { n: int }
+    //     PosInf {}
+    // }
+    const { data: extendedInteger_t } = defineMultiConstructorStruct("ExtendedInteger", {
+        NegInf: {},
+        Finite: {
+            n: int_t
+        },
+        PosInf: {}
+    }, onlyData);
+    // struct IntervalBoundary {
+    //     boundary: ExtendedInteger,
+    //     isInclusive: boolean
+    // }
+    const { data: intervalBoundary_t } = defineSingleConstructorStruct("IntervalBoundary", {
+        boundary: extendedInteger_t,
+        isInclusive: bool_t
+    }, onlyData);
+    // struct Interval {
+    //     from: IntervalBoundary,
+    //     to: IntervalBoundary,
+    // }
+    const { data: interval_t } = defineSingleConstructorStruct("Interval", {
+        from: intervalBoundary_t,
+        to: intervalBoundary_t
+    }, onlyData);
+    // struct Vote {
+    //     No {}
+    //     Yes {}
+    //     Abstain {}
+    // }
+    const { data: vote_t } = defineMultiConstructorStruct("Vote", {
+        No: {},
+        Yes: {},
+        Abstain: {}
+    }, onlyData);
+    // struct Delegatee {
+    //     StakePool { poolKeyHash: PubKeyHash }
+    //     DRep { drep: Credential }
+    //     PoolAndDRep {
+    //         poolKeyHash: PubKeyHash,
+    //         drep: Credential
+    //     }
+    // }
+    const { data: delegatee_t } = defineMultiConstructorStruct("Delegatee", {
+        StakePool: {
+            poolKeyHash: pubKeyHash_t
+        },
+        DRep: {
+            drep: credential_t
+        },
+        PoolAndDRep: {
+            poolKeyHash: pubKeyHash_t,
+            drep: credential_t
+        }
+    }, onlyData);
+    // struct Certificate {
+    //     StakeRegistration {
+    //         stakeKey: Credential,
+    //         deposit: Optional<int>
+    //     }
+    //     StakeDeRegistration {
+    //         stakeKey: Credential,
+    //         refund: Optional<int>
+    //     }
+    //     Delegation {
+    //         delegator: Credential,
+    //         delegatee: Delegatee
+    //     }
+    //     RegistrationAndDelegation {
+    //         delegator: Credential,
+    //         delegatee: Delegatee,
+    //         lovelacesDeposit: int
+    //     }
+    //     DRepRegistration {
+    //         drep: Credential,
+    //         lovelacesDeposit: int
+    //     }
+    //     DRepUpdate {
+    //         drep: Credential
+    //     }
+    //     DRepDeRegistration {
+    //         drep: Credential,
+    //         refund: int
+    //     }
+    //     PoolRegistration {
+    //         poolId: PubKeyHash,
+    //         poolVRF: PubKeyHash
+    //     }
+    //     PoolRetire {
+    //         poolId: PubKeyHash,
+    //         epoch: int
+    //     }
+    //     CommitteeHotAuthorization {
+    //         cold: Credential,
+    //         hot: Credential
+    //     }
+    //     CommitteeResignation {
+    //         cold: Credential
+    //     }
+    // }
+    const opt_int_t = program.getAppliedGeneric(TirDataOptT.toTirTypeKey(), [int_t]);
+    if (!opt_int_t)
+        throw new Error("expected opt_int_t");
+    const { data: certificate_t } = defineMultiConstructorStruct("Certificate", {
+        StakeRegistration: {
+            stakeKey: credential_t,
+            deposit: opt_int_t
+        },
+        StakeDeRegistration: {
+            stakeKey: credential_t,
+            refund: opt_int_t
+        },
+        Delegation: {
+            delegator: credential_t,
+            delegatee: delegatee_t
+        },
+        RegistrationAndDelegation: {
+            delegator: credential_t,
+            delegatee: delegatee_t,
+            lovelacesDeposit: int_t
+        },
+        DRepRegistration: {
+            drep: credential_t,
+            lovelacesDeposit: int_t
+        },
+        DRepUpdate: {
+            drep: credential_t
+        },
+        DRepDeRegistration: {
+            drep: credential_t,
+            refund: int_t
+        },
+        PoolRegistration: {
+            poolId: pubKeyHash_t,
+            poolVRF: bytes_t
+        },
+        PoolRetire: {
+            poolId: pubKeyHash_t,
+            epoch: int_t
+        },
+        CommitteeHotAuthorization: {
+            cold: credential_t,
+            hot: credential_t
+        },
+        CommitteeResignation: { cold: credential_t }
+    }, onlyData);
+    // struct Tx {
+    //     inputs: List<TxIn>,
+    //     refInputs: List<TxIn>,
+    //     outputs: List<TxOut>,
+    //     fee: int,
+    //     mint: Value,
+    //     certificates: List<Certificate>,
+    //     withdrawals: LinearMap<Credential, int>,
+    //     validityInterval: Interval,
+    //     requiredSigners: List<PubKeyHash>,
+    //     redeemers: LinearMap<ScriptPurpose, data>,
+    //     datums: LinearMap<Hash32, data>,
+    //     hash: TxHash,
+    //     votes: LinearMap<Voter, LinearMap<TxOutRef, Vote>>,
+    //     proposals: List<ProposalProcedure>,
+    //     currentTreasury: Optional<int>,
+    //     treasuryDonation: Optional<int>
+    // }
+    const list_txIn_t = program.getAppliedGeneric(TirListT.toTirTypeKey(), [txIn_t]);
+    if (!list_txIn_t)
+        throw new Error("expected list_txIn_t");
+    const list_txOut_t = program.getAppliedGeneric(TirListT.toTirTypeKey(), [txOut_t]);
+    if (!list_txOut_t)
+        throw new Error("expected list_txOut_t");
+    const list_certificate_t = program.getAppliedGeneric(TirListT.toTirTypeKey(), [certificate_t]);
+    if (!list_certificate_t)
+        throw new Error("expected list_certificate_t");
+    const list_pubKeyHash_t = program.getAppliedGeneric(TirListT.toTirTypeKey(), [pubKeyHash_t]);
+    if (!list_pubKeyHash_t)
+        throw new Error("expected list_pubKeyHash_t");
+    const map_scriptPurpose_data_t = program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [scriptPurpose_t, data_t]);
+    if (!map_scriptPurpose_data_t)
+        throw new Error("expected map_scriptPurpose_data_t");
+    const map_hash32_data_t = program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [hash32_t, data_t]);
+    if (!map_hash32_data_t)
+        throw new Error("expected map_hash32_data_t");
+    const map_txOutRef_vote_t = program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [txOutRef_t, vote_t]);
+    if (!map_txOutRef_vote_t)
+        throw new Error("expected map_txOutRef_vote_t");
+    const map_voter_map_txOutRef_vote_t = program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [voter_t, map_txOutRef_vote_t]);
+    if (!map_voter_map_txOutRef_vote_t)
+        throw new Error("expected map_voter_map_txOutRef_vote_t");
+    const list_proposalProcedure_t = program.getAppliedGeneric(TirListT.toTirTypeKey(), [proposalProcedure_t]);
+    if (!list_proposalProcedure_t)
+        throw new Error("expected list_proposalProcedure_t");
+    const { data: tx_t } = defineSingleConstructorStruct("Tx", {
+        inputs: list_txIn_t,
+        refInputs: list_txIn_t,
+        outputs: list_txOut_t,
+        fee: int_t,
+        mint: value_t,
+        certificates: list_certificate_t,
+        withdrawals: map_cred_int_t,
+        validityInterval: interval_t,
+        requiredSigners: list_pubKeyHash_t,
+        redeemers: map_scriptPurpose_data_t,
+        datums: map_hash32_data_t,
+        hash: txHash_t,
+        votes: map_voter_map_txOutRef_vote_t,
+        proposals: list_proposalProcedure_t,
+        currentTreasury: opt_int_t,
+        treasuryDonation: opt_int_t
+    }, onlyData);
+    // tagged data struct ScriptContext {
+    //     tx: Tx,
+    //     redeemer: data,
+    //     purpose: ScriptInfo
+    // }
+    const { data: scriptContext_t } = defineSingleConstructorStruct("ScriptContext", {
+        tx: tx_t,
+        redeemer: data_t,
+        purpose: scriptInfo_t
+    }, onlyData);
+    preludeScope.readonly();
+}