@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

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

@@ -139,7 +139,7 @@ export function populatePreludeScope(program) {
         return { sop, data };
     }
     function defineMultiConstructorStruct(name, constrs, opts, methodsNames = new Map()) {
-        const { sop, data } = mkMultiConstructorStruct(name, constrs);
+        const { sop, data } = mkMultiConstructorStruct(name, constrs, methodsNames);
         const sop_key = sop.toTirTypeKey();
         const data_key = data.toTirTypeKey();
         if (opts.sop)
@@ -166,6 +166,7 @@ export function populatePreludeScope(program) {
         id: txHash_t,
         index: int_t
     }, onlyData);
+    const getCredentialHashFuncName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "getCredentialHash";
     const { data: credential_t } = defineMultiConstructorStruct("Credential", {
         PubKey: {
             hash: pubKeyHash_t
@@ -173,28 +174,13 @@ export function populatePreludeScope(program) {
         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
-    //     )
-    // );
+    }, onlyData, new Map([
+        [
+            "hash",
+            getCredentialHashFuncName
+        ],
+    ]));
+    preludeScope.program.functions.set(getCredentialHashFuncName, new TirInlineClosedIR(new TirFuncT([credential_t], hash28_t), (ctx) => IRNative._getCredentialsHash, SourceRange.unknown));
     const changeParams_t = _defineUnambigousAlias("ChangedParameters", map_int_data_t);
     const { data: rational_t } = defineSingleConstructorStruct("Rational", {
         numerator: int_t,
@@ -354,6 +340,127 @@ export function populatePreludeScope(program) {
             proposal: proposalProcedure_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 ScriptInfo {
     //     Mint { policy: PolicyId }
     //     Spend {
@@ -390,14 +497,14 @@ export function populatePreludeScope(program) {
             credential: credential_t
         },
         Certificate: {
-            index: int_t,
-            certificate: credential_t
+            certificateIndex: int_t,
+            certificate: certificate_t
         },
         Vote: {
             voter: voter_t
         },
         Propose: {
-            index: int_t,
+            proposalIndex: int_t,
             proposal: proposalProcedure_t
         }
     }, onlyData);
@@ -501,7 +608,7 @@ export function populatePreludeScope(program) {
     //     resolved: TxOut
     // }
     const { data: txIn_t } = defineSingleConstructorStruct("TxIn", {
-        txOutRef: txOutRef_t,
+        ref: txOutRef_t,
         resolved: txOut_t
     }, onlyData);
     // struct ExtendedInteger {
@@ -532,127 +639,6 @@ export function populatePreludeScope(program) {
         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>,
@@ -726,5 +712,5 @@ export function populatePreludeScope(program) {
         redeemer: data_t,
         purpose: scriptInfo_t
     }, onlyData);
-    preludeScope.readonly();
+    // preludeScope.readonly();
 }

package/dist/compiler/tir/statements/TirAssertStmt.d.ts

@@ -12,6 +12,8 @@ export declare class TirAssertStmt implements ITirStmt {
     condition: TirExpr, 
     /** must be string */
     elseExpr: TirExpr | undefined, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
     toSafeCondition(): TirExpr;

package/dist/compiler/tir/statements/TirAssertStmt.js

@@ -13,6 +13,16 @@ export class TirAssertStmt {
         this.elseExpr = elseExpr;
         this.range = range;
     }
+    toString() {
+        return (`assert ${this.condition.toString()}` +
+            (this.elseExpr ? ` else ${this.elseExpr.toString()}` : ""));
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return (`assert ${this.condition.pretty(indent)}` +
+            (this.elseExpr ? ` else ${this.elseExpr.pretty(indent)}` : ""));
+    }
     definitelyTerminates() { return false; }
     deps() {
         const deps = this.condition.deps();

package/dist/compiler/tir/statements/TirAssignmentStmt.d.ts

@@ -7,6 +7,8 @@ export declare class TirAssignmentStmt implements ITirStmt {
     readonly assignedExpr: TirExpr;
     readonly range: SourceRange;
     constructor(varIdentifier: TirVariableAccessExpr, assignedExpr: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

package/dist/compiler/tir/statements/TirAssignmentStmt.js

@@ -7,6 +7,14 @@ export class TirAssignmentStmt {
         this.assignedExpr = assignedExpr;
         this.range = range;
     }
+    toString() {
+        return `${this.varIdentifier.toString()} = ${this.assignedExpr.toString()};`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `${this.varIdentifier.pretty(indent)} = ${this.assignedExpr.pretty(indent)}`;
+    }
     definitelyTerminates() { return false; }
     deps() {
         return this.varIdentifier.deps();

package/dist/compiler/tir/statements/TirBlockStmt.d.ts

@@ -4,6 +4,8 @@ export declare class TirBlockStmt implements ITirStmt {
     stmts: TirStmt[];
     readonly range: SourceRange;
     constructor(stmts: TirStmt[], range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

package/dist/compiler/tir/statements/TirBlockStmt.js

@@ -8,6 +8,22 @@ export class TirBlockStmt {
         this.stmts = stmts;
         this.range = range;
     }
+    toString() {
+        return (`{ ` +
+            this.stmts.map(s => s.toString()).join("; ") +
+            `}`);
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        if (this.stmts.length === 0)
+            return `${indent_0}{ }`;
+        return (`{` +
+            "\n" + indent_1 + this.stmts.map(s => s.pretty(indent + 1)).join(`;${indent_1}`) +
+            `${indent_0}}`);
+    }
     definitelyTerminates() {
         return this.stmts.some(stmt => stmt.definitelyTerminates());
     }

package/dist/compiler/tir/statements/TirBreakStmt.d.ts

@@ -3,6 +3,8 @@ import { ITirStmt } from "./TirStmt.js";
 export declare class TirBreakStmt implements ITirStmt {
     readonly range: SourceRange;
     constructor(range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

package/dist/compiler/tir/statements/TirBreakStmt.js

@@ -3,6 +3,14 @@ export class TirBreakStmt {
     constructor(range) {
         this.range = range;
     }
+    toString() {
+        return `break`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `break`;
+    }
     // loops are transoformed into recursive functions
     // and break statements are transformed into return statements
     // so this statement does terminate the function

package/dist/compiler/tir/statements/TirContinueStmt.d.ts

@@ -3,6 +3,8 @@ import { ITirStmt } from "./TirStmt.js";
 export declare class TirContinueStmt implements ITirStmt {
     readonly range: SourceRange;
     constructor(range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

package/dist/compiler/tir/statements/TirContinueStmt.js

@@ -3,6 +3,14 @@ export class TirContinueStmt {
     constructor(range) {
         this.range = range;
     }
+    toString() {
+        return `continue`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `continue`;
+    }
     // loops are transoformed into recursive functions
     // and continue statements are transformed into return statements
     // so this statement does terminate the function

package/dist/compiler/tir/statements/TirFailStmt.d.ts

@@ -8,6 +8,8 @@ export declare class TirFailStmt implements ITirStmt {
     constructor(
     /** must be string (or utf8 bytes) */
     failMsgExpr: TirExpr | undefined, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

package/dist/compiler/tir/statements/TirFailStmt.js

@@ -7,6 +7,14 @@ export class TirFailStmt {
         this.failMsgExpr = failMsgExpr;
         this.range = range;
     }
+    toString() {
+        return `fail${this.failMsgExpr ? ` ${this.failMsgExpr.toString()}` : ""}`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `fail${this.failMsgExpr ? ` ${this.failMsgExpr.pretty(indent)}` : ""}`;
+    }
     definitelyTerminates() { return true; }
     deps() {
         return this.failMsgExpr?.deps() ?? [];

package/dist/compiler/tir/statements/TirForOfStmt.d.ts

@@ -11,6 +11,8 @@ export declare class TirForOfStmt implements ITirStmt {
     body: TirStmt;
     readonly range: SourceRange;
     constructor(elemDeclaration: TirVarDecl, iterable: TirExpr, body: TirStmt, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

package/dist/compiler/tir/statements/TirForOfStmt.js

@@ -14,6 +14,20 @@ export class TirForOfStmt {
         this.body = body;
         this.range = range;
     }
+    toString() {
+        return (`for( ${this.elemDeclaration.toString()} of ${this.iterable.toString()} ) ` +
+            this.body.toString());
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        return (`for(` +
+            indent_1 + this.elemDeclaration.pretty(indent + 1) + ` of ` + this.iterable.pretty(indent + 1) +
+            `${indent_0}) ` +
+            this.body.pretty(indent));
+    }
     definitelyTerminates() {
         return this.body.definitelyTerminates();
     }

package/dist/compiler/tir/statements/TirForStmt.d.ts

@@ -14,6 +14,8 @@ export declare class TirForStmt implements ITirStmt {
     body: TirStmt;
     readonly range: SourceRange;
     constructor(init: TirSimpleVarDecl[], condition: TirExpr | undefined, update: TirStmt[] | undefined, body: TirStmt, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

package/dist/compiler/tir/statements/TirForStmt.js

@@ -18,6 +18,27 @@ export class TirForStmt {
         this.body = body;
         this.range = range;
     }
+    toString() {
+        return (`for( ${this.init.map(v => v.toString()).join(", ")}; ` +
+            `${this.condition?.toString() ?? ""}; ` +
+            `${this.update?.map(s => s.toString()).join(", ") ?? ""} ) ` +
+            `${this.body.toString()}`);
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        const initPart = this.init.map(v => v.pretty(indent + 1)).join(`,${indent_1}`);
+        const condPart = this.condition ? this.condition.pretty(indent + 1) : "";
+        const updatePart = (this.update ?? []).map(s => s.pretty(indent + 1)).join(`,${indent_1}`);
+        return (`for(` +
+            indent_1 + initPart + `;` +
+            indent_1 + condPart + `;` +
+            indent_1 + updatePart +
+            `${indent_0}) ` +
+            this.body.pretty(indent));
+    }
     definitelyTerminates() {
         return this.body.definitelyTerminates() || (this.update?.some(stmt => stmt.definitelyTerminates()) ?? false);
     }

package/dist/compiler/tir/statements/TirIfStmt.d.ts

@@ -7,6 +7,8 @@ export declare class TirIfStmt implements ITirStmt {
     elseBranch: TirStmt | undefined;
     readonly range: SourceRange;
     constructor(condition: TirExpr, thenBranch: TirStmt, elseBranch: TirStmt | undefined, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

package/dist/compiler/tir/statements/TirIfStmt.js

@@ -10,6 +10,22 @@ export class TirIfStmt {
         this.elseBranch = elseBranch;
         this.range = range;
     }
+    toString() {
+        return (`if( ${this.condition.toString()} ) ` +
+            this.thenBranch.toString() +
+            (this.elseBranch ? ` else ${this.elseBranch.toString()}` : ``));
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        return (`if(` +
+            indent_1 + this.condition.pretty(indent + 1) +
+            `${indent_0}) ` +
+            this.thenBranch.pretty(indent) +
+            (this.elseBranch ? ` else ${this.elseBranch.pretty(indent)}` : ""));
+    }
     definitelyTerminates() {
         return (this.thenBranch.definitelyTerminates()
             && (this.elseBranch?.definitelyTerminates() ?? false));

package/dist/compiler/tir/statements/TirMatchStmt.d.ts

@@ -9,6 +9,8 @@ export declare class TirMatchStmt implements ITirStmt {
     wildcardCase: TirMatchStmtWildcardCase | undefined;
     readonly range: SourceRange;
     constructor(matchExpr: TirExpr, cases: TirMatchStmtCase[], wildcardCase: TirMatchStmtWildcardCase | undefined, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }

package/dist/compiler/tir/statements/TirMatchStmt.js

@@ -11,6 +11,36 @@ export class TirMatchStmt {
         this.wildcardCase = wildcardCase;
         this.range = range;
     }
+    toString() {
+        return (`match ( ${this.matchExpr.toString()} ) { ` +
+            this.cases.map(c => `when ${c.pattern.toString()}: ${c.body.toString()};`).join(" ") +
+            (this.wildcardCase ? ` else ${this.wildcardCase.body.toString()};` : "") +
+            ` }`);
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        const caseParts = this.cases.map(c => `when ${c.pattern.pretty(indent + 1)}: ${c.body.pretty(indent + 1)}`);
+        const casesPart = caseParts.length > 0
+            ? indent_1 + caseParts.join(`;${indent_1}`) + ";"
+            : "";
+        const wildcardPart = this.wildcardCase
+            ? indent_1 + `else ${this.wildcardCase.body.pretty(indent + 1)};`
+            : "";
+        if (caseParts.length === 0 && !this.wildcardCase) {
+            return (`match (` +
+                indent_1 + this.matchExpr.pretty(indent + 1) +
+                `${indent_0}) { }`);
+        }
+        return (`match (` +
+            indent_1 + this.matchExpr.pretty(indent + 1) +
+            `${indent_0}) {` +
+            casesPart +
+            wildcardPart +
+            `${indent_0}}`);
+    }
     definitelyTerminates() {
         return this.cases.every(({ body }) => body.definitelyTerminates());
     }

package/dist/compiler/tir/statements/TirReturnStmt.d.ts

@@ -5,6 +5,8 @@ export declare class TirReturnStmt implements ITirStmt {
     value: TirExpr;
     readonly range: SourceRange;
     constructor(value: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     definitelyTerminates(): boolean;
     deps(): string[];
 }