@proto-kit/common 0.1.1-develop.153

package/dist/utils/merkletree/RollupMerkleTree.js

@@ -0,0 +1,246 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/* eslint-disable id-length */
+/* eslint-disable line-comment-position */
+/* eslint-disable no-inline-comments */
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+import { Bool, Circuit, Field, Poseidon, Struct } from "snarkyjs";
+import { notInCircuit } from "../utils";
+// external API
+// eslint-disable-next-line @typescript-eslint/no-use-before-define
+export { RollupMerkleTree, RollupMerkleWitness };
+// internal API
+// eslint-disable-next-line @typescript-eslint/no-use-before-define
+export { maybeSwap };
+/**
+ * The {@link BaseMerkleWitness} class defines a circuit-compatible base class
+ * for [Merkle Witness'](https://computersciencewiki.org/index.php/Merkle_proof).
+ */
+class RollupMerkleWitness extends Struct({
+    path: Circuit.array(Field, 256 - 1),
+    isLeft: Circuit.array(Bool, 256 - 1),
+}) {
+    height() {
+        return RollupMerkleWitness.height;
+    }
+    /**
+     * Calculates a root depending on the leaf value.
+     * @param leaf Value of the leaf node that belongs to this Witness.
+     * @returns The calculated root.
+     */
+    calculateRoot(hash) {
+        const n = this.height();
+        for (let index = 1; index < n; ++index) {
+            const isLeft = this.isLeft[index - 1];
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            const [left, right] = maybeSwap(isLeft, hash, this.path[index - 1]);
+            hash = Poseidon.hash([left, right]);
+        }
+        return hash;
+    }
+    /**
+     * Calculates the index of the leaf node that belongs to this Witness.
+     * @returns Index of the leaf.
+     */
+    calculateIndex() {
+        let powerOfTwo = Field(1);
+        let index = Field(0);
+        const n = this.height();
+        // eslint-disable-next-line no-underscore-dangle
+        for (let index_ = 1; index_ < n; ++index_) {
+            index = Circuit.if(this.isLeft[index_ - 1], index, index.add(powerOfTwo));
+            powerOfTwo = powerOfTwo.mul(2);
+        }
+        return index;
+    }
+}
+RollupMerkleWitness.height = 256;
+/**
+ * A [Merkle Tree](https://en.wikipedia.org/wiki/Merkle_tree) is a binary tree in
+ * which every leaf is the cryptography hash of a piece of data,
+ * and every node is the hash of the concatenation of its two child nodes.
+ *
+ * A Merkle Tree allows developers to easily and securely verify
+ * the integrity of large amounts of data.
+ *
+ * Take a look at our [documentation](https://docs.minaprotocol.com/en/zkapps)
+ * on how to use Merkle Trees in combination with zkApps and
+ * zero knowledge programming!
+ *
+ * Levels are indexed from leaves (level 0) to root (level N - 1).
+ */
+class RollupMerkleTree {
+    static get leafCount() {
+        return 2n ** BigInt(RollupMerkleTree.height - 1);
+    }
+    constructor(store) {
+        this.store = store;
+        // eslint-disable-next-line @shopify/prefer-class-properties
+        this.zeroes = [0n];
+        for (let index = 1; index < RollupMerkleTree.height; index += 1) {
+            const previousLevel = Field(this.zeroes[index - 1]);
+            this.zeroes.push(Poseidon.hash([previousLevel, previousLevel]).toBigInt());
+        }
+    }
+    /**
+     * Returns a node which lives at a given index and level.
+     * @param level Level of the node.
+     * @param index Index of the node.
+     * @returns The data of the node.
+     */
+    getNode(level, index) {
+        return Field(this.store.getNode(index, level) ?? this.zeroes[level]);
+    }
+    /**
+     * Returns the root of the [Merkle Tree](https://en.wikipedia.org/wiki/Merkle_tree).
+     * @returns The root of the Merkle Tree.
+     */
+    getRoot() {
+        return this.getNode(RollupMerkleTree.height - 1, 0n);
+    }
+    // eslint-disable-next-line no-warning-comments
+    // TODO: this allows to set a node at an index larger than the size. OK?
+    setNode(level, index, value) {
+        this.store.setNode(index, level, value.toBigInt());
+    }
+    /**
+     * TODO: if this is passed an index bigger than the max, it will set a couple
+     * of out-of-bounds nodes but not affect the real Merkle root. OK?
+     */
+    /**
+     * Sets the value of a leaf node at a given index to a given value.
+     * @param index Position of the leaf node.
+     * @param leaf New value.
+     */
+    setLeaf(index, leaf) {
+        if (index >= this.leafCount) {
+            index %= this.leafCount;
+        }
+        this.store.openTransaction();
+        this.setNode(0, index, leaf);
+        let currentIndex = index;
+        for (let level = 1; level < RollupMerkleTree.height; level += 1) {
+            currentIndex /= 2n;
+            const left = this.getNode(level - 1, currentIndex * 2n);
+            const right = this.getNode(level - 1, currentIndex * 2n + 1n);
+            this.setNode(level, currentIndex, Poseidon.hash([left, right]));
+        }
+        this.store.commit();
+    }
+    /**
+     * Returns the witness (also known as
+     * [Merkle Proof or Merkle Witness](https://computersciencewiki.org/index.php/Merkle_proof))
+     * for the leaf at the given index.
+     * @param index Position of the leaf node.
+     * @returns The witness that belongs to the leaf.
+     */
+    getWitness(index) {
+        if (index >= this.leafCount) {
+            index %= this.leafCount;
+        }
+        const path = [];
+        const isLefts = [];
+        for (let level = 0; level < RollupMerkleTree.height - 1; level += 1) {
+            const isLeft = index % 2n === 0n;
+            const sibling = this.getNode(level, isLeft ? index + 1n : index - 1n);
+            isLefts.push(Bool(isLeft));
+            path.push(sibling);
+            index /= 2n;
+        }
+        return new RollupMerkleWitness({
+            isLeft: isLefts,
+            path,
+        });
+    }
+    // eslint-disable-next-line no-warning-comments, max-len
+    // TODO: should this take an optional offset? should it fail if the array is too long?
+    /**
+     * Fills all leaves of the tree.
+     * @param leaves Values to fill the leaves with.
+     */
+    fill(leaves) {
+        leaves.forEach((value, index) => {
+            this.setLeaf(BigInt(index), value);
+        });
+    }
+    /**
+     * Returns the amount of leaf nodes.
+     * @returns Amount of leaf nodes.
+     */
+    get leafCount() {
+        return RollupMerkleTree.leafCount;
+    }
+}
+RollupMerkleTree.height = 256;
+__decorate([
+    notInCircuit(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, BigInt]),
+    __metadata("design:returntype", Field)
+], RollupMerkleTree.prototype, "getNode", null);
+__decorate([
+    notInCircuit(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Field)
+], RollupMerkleTree.prototype, "getRoot", null);
+__decorate([
+    notInCircuit(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BigInt, Field]),
+    __metadata("design:returntype", void 0)
+], RollupMerkleTree.prototype, "setLeaf", null);
+__decorate([
+    notInCircuit(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BigInt]),
+    __metadata("design:returntype", RollupMerkleWitness)
+], RollupMerkleTree.prototype, "getWitness", null);
+__decorate([
+    notInCircuit(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], RollupMerkleTree.prototype, "fill", null);
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var MerkleTreeUtils;
+(function (MerkleTreeUtils) {
+    function normalizeKey(key) {
+        // if(NJORD_MERKLE_TREE_HEIGHT < 256){
+        //     return fieldMod(key, Field(RollupMerkleTree.leafCount).toConstant())
+        // eslint-disable-next-line max-len
+        //     // return modPower2(key, RollupMerkleTree.height - 1) //TODO Fix modPower2
+        // }else{
+        return key;
+        // }
+    }
+    MerkleTreeUtils.normalizeKey = normalizeKey;
+    function checkMembership(witness, root, key, value) {
+        const root2 = witness.calculateRoot(value);
+        const key2 = witness.calculateIndex();
+        key.assertEquals(key2, "Keys of MerkleWitness does not match");
+        return root.equals(root2);
+    }
+    MerkleTreeUtils.checkMembership = checkMembership;
+    function computeRoot(witness, value) {
+        return witness.calculateRoot(value);
+    }
+    MerkleTreeUtils.computeRoot = computeRoot;
+})(MerkleTreeUtils || (MerkleTreeUtils = {}));
+/**
+ * More efficient version of `maybeSwapBad` which
+ * reuses an intermediate variable
+ */
+function maybeSwap(b, x, y) {
+    const m = b.toField().mul(x.sub(y)); // b*(x - y)
+    const x1 = y.add(m); // y + b*(x - y)
+    const y2 = x.sub(m); // x - b*(x - y) = x + b*(y - x)
+    return [x1, y2];
+}

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function requireTrue(condition: boolean, errorOrFunction: Error | (() => Error)): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CACzB,SAAS,EAAE,OAAO,EAClB,eAAe,EAAE,KAAK,GAAG,CAAC,MAAM,KAAK,CAAC,GACrC,IAAI,CAMN"}

package/dist/utils.js

@@ -0,0 +1,7 @@
+export function requireTrue(condition, errorOrFunction) {
+    if (!condition) {
+        throw typeof errorOrFunction === "function"
+            ? errorOrFunction()
+            : errorOrFunction;
+    }
+}

package/dist/zkProgrammable/ProvableMethodExecutionContext.d.ts

@@ -0,0 +1,53 @@
+import type { FlexibleProvable, Proof } from "snarkyjs";
+export declare class ProvableMethodExecutionResult {
+    moduleName?: string;
+    methodName?: string;
+    args?: FlexibleProvable<unknown>[];
+    prover?: () => Promise<Proof<unknown, unknown>>;
+    prove<ProofType extends Proof<unknown, unknown>>(): Promise<ProofType>;
+}
+/**
+ * Execution context used to wrap runtime module methods,
+ * allowing them to post relevant information (such as execution status)
+ * into the context without any unnecessary 'prop drilling'.
+ */
+export declare class ProvableMethodExecutionContext {
+    id: string;
+    methods: string[];
+    result: ProvableMethodExecutionResult;
+    /**
+     * Adds a method prover to the current execution context,
+     * which can be collected and ran asynchronously at a later point in time.
+     *
+     * @param prove - Prover function to be ran later,
+     * when the method execution needs to be proven
+     */
+    setProver(prover: () => Promise<Proof<unknown, unknown>>): void;
+    /**
+     * Adds a method to the method execution stack, reseting the execution context
+     * in a case a new top-level (non nested) method call is made.
+     *
+     * @param methodName - Name of the method being captured in the context
+     */
+    beforeMethod(moduleName: string, methodName: string, args: FlexibleProvable<unknown>[]): void;
+    /**
+     * Removes the latest method from the execution context stack,
+     * keeping track of the amount of 'unfinished' methods. Allowing
+     * for the context to distinguish between top-level and nested method calls.
+     */
+    afterMethod(): void;
+    get isTopLevel(): boolean;
+    get isFinished(): boolean;
+    /**
+     * @returns - Current execution context state
+     */
+    current(): {
+        isFinished: boolean;
+        result: ProvableMethodExecutionResult;
+    };
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear(): void;
+}
+//# sourceMappingURL=ProvableMethodExecutionContext.d.ts.map

package/dist/zkProgrammable/ProvableMethodExecutionContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../src/zkProgrammable/ProvableMethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAaxD,qBAAa,6BAA6B;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,IAAI,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAC;IAEnC,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;IAE1C,KAAK,CAEhB,SAAS,SAAS,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,KACtC,OAAO,CAAC,SAAS,CAAC;CAaxB;AAED;;;;GAIG;AACH,qBACa,8BAA8B;IAClC,EAAE,SAAc;IAEhB,OAAO,EAAE,MAAM,EAAE,CAAM;IAEvB,MAAM,EAAE,6BAA6B,CACN;IAItC;;;;;;OAMG;IACI,SAAS,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAI/D;;;;;OAKG;IACI,YAAY,CACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE;IAYnC;;;;OAIG;IACI,WAAW;IAIlB,IAAW,UAAU,YAEpB;IAED,IAAW,UAAU,YAEpB;IAED;;OAEG;IACI,OAAO;;;;IAOd;;OAEG;IACI,KAAK;CAGb"}

package/dist/zkProgrammable/ProvableMethodExecutionContext.js

@@ -0,0 +1,98 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { singleton } from "tsyringe";
+import uniqueId from "lodash/uniqueId";
+const errors = {
+    moduleOrMethodNameNotSet: () => new Error("Module or method name not set"),
+    proverNotSet: (moduleName, methodName) => new Error(`Prover not set for '${moduleName}.${methodName}', did you forget to decorate your method?`),
+};
+export class ProvableMethodExecutionResult {
+    async prove() {
+        if (!this.prover) {
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (!this.moduleName || !this.methodName) {
+                throw errors.moduleOrMethodNameNotSet();
+            }
+            throw errors.proverNotSet(this.moduleName, this.methodName);
+        }
+        // turn the prover result into the desired proof type
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return (await this.prover());
+    }
+}
+/**
+ * Execution context used to wrap runtime module methods,
+ * allowing them to post relevant information (such as execution status)
+ * into the context without any unnecessary 'prop drilling'.
+ */
+let ProvableMethodExecutionContext = class ProvableMethodExecutionContext {
+    constructor() {
+        this.id = uniqueId();
+        this.methods = [];
+        this.result = new ProvableMethodExecutionResult();
+    }
+    // eslint-disable-next-line no-warning-comments,max-len
+    // TODO See if we should make this class generic, bc I think we can persist the type
+    /**
+     * Adds a method prover to the current execution context,
+     * which can be collected and ran asynchronously at a later point in time.
+     *
+     * @param prove - Prover function to be ran later,
+     * when the method execution needs to be proven
+     */
+    setProver(prover) {
+        this.result.prover = prover;
+    }
+    /**
+     * Adds a method to the method execution stack, reseting the execution context
+     * in a case a new top-level (non nested) method call is made.
+     *
+     * @param methodName - Name of the method being captured in the context
+     */
+    beforeMethod(moduleName, methodName, args) {
+        if (this.isFinished) {
+            this.clear();
+            this.result.moduleName = moduleName;
+            this.result.methodName = methodName;
+            this.result.args = args;
+        }
+        this.methods.push(methodName);
+    }
+    /**
+     * Removes the latest method from the execution context stack,
+     * keeping track of the amount of 'unfinished' methods. Allowing
+     * for the context to distinguish between top-level and nested method calls.
+     */
+    afterMethod() {
+        this.methods.pop();
+    }
+    get isTopLevel() {
+        return this.methods.length === 1;
+    }
+    get isFinished() {
+        return this.methods.length === 0;
+    }
+    /**
+     * @returns - Current execution context state
+     */
+    current() {
+        return {
+            isFinished: this.isFinished,
+            result: this.result,
+        };
+    }
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear() {
+        this.result = new ProvableMethodExecutionResult();
+    }
+};
+ProvableMethodExecutionContext = __decorate([
+    singleton()
+], ProvableMethodExecutionContext);
+export { ProvableMethodExecutionContext };

package/dist/zkProgrammable/ZkProgrammable.d.ts

@@ -0,0 +1,32 @@
+import { Experimental, FlexibleProvablePure, Proof } from "snarkyjs";
+export interface CompileArtifact {
+    verificationKey: string;
+}
+export interface AreProofsEnabled {
+    areProofsEnabled: boolean;
+    setProofsEnabled: (areProofsEnabled: boolean) => void;
+}
+export interface Verify<PublicInput, PublicOutput> {
+    (proof: Proof<PublicInput, PublicOutput>): Promise<boolean>;
+}
+export interface Compile {
+    (): Promise<CompileArtifact>;
+}
+export interface PlainZkProgram<PublicInput = undefined, PublicOutput = void> {
+    compile: Compile;
+    verify: Verify<PublicInput, PublicOutput>;
+    Proof: ReturnType<typeof Experimental.ZkProgram.Proof<FlexibleProvablePure<PublicInput>, FlexibleProvablePure<PublicOutput>>>;
+    methods: Record<string, ((...args: any) => Promise<Proof<PublicInput, PublicOutput>>) | ((publicInput: PublicInput, ...args: any) => Promise<Proof<PublicInput, PublicOutput>>)>;
+}
+export declare function verifyToMockable<PublicInput, PublicOutput>(verify: Verify<PublicInput, PublicOutput>, { areProofsEnabled }: AreProofsEnabled): (proof: Proof<PublicInput, PublicOutput>) => Promise<boolean>;
+export declare const mockVerificationKey = "mock-verification-key";
+export declare function compileToMockable(compile: Compile, { areProofsEnabled }: AreProofsEnabled): () => Promise<CompileArtifact>;
+export declare abstract class ZkProgrammable<PublicInput = undefined, PublicOutput = void> {
+    abstract get appChain(): AreProofsEnabled | undefined;
+    abstract zkProgramFactory(): PlainZkProgram<PublicInput, PublicOutput>;
+    get zkProgram(): PlainZkProgram<PublicInput, PublicOutput>;
+}
+export interface WithZkProgrammable<PublicInput = undefined, PublicOutput = void> {
+    zkProgrammable: ZkProgrammable<PublicInput, PublicOutput>;
+}
+//# sourceMappingURL=ZkProgrammable.d.ts.map

package/dist/zkProgrammable/ZkProgrammable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZkProgrammable.d.ts","sourceRoot":"","sources":["../../src/zkProgrammable/ZkProgrammable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAUrE,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,gBAAgB,EAAE,CAAC,gBAAgB,EAAE,OAAO,KAAK,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,MAAM,CAAC,WAAW,EAAE,YAAY;IAC/C,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,EAAE,YAAY,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7D;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc,CAAC,WAAW,GAAG,SAAS,EAAE,YAAY,GAAG,IAAI;IAC1E,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;IAC1C,KAAK,EAAE,UAAU,CACf,OAAO,YAAY,CAAC,SAAS,CAAC,KAAK,CACjC,oBAAoB,CAAC,WAAW,CAAC,EACjC,oBAAoB,CAAC,YAAY,CAAC,CACnC,CACF,CAAC;IACF,OAAO,EAAE,MAAM,CACb,MAAM,EACJ,CAAC,CAEC,GAAG,IAAI,EAAE,GAAG,KACT,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC,CAAC,GAC/C,CAAC,CACC,WAAW,EAAE,WAAW,EAExB,GAAG,IAAI,EAAE,GAAG,KACT,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC,CAAC,CAClD,CAAC;CACH;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,YAAY,EACxD,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,YAAY,CAAC,EACzC,EAAE,gBAAgB,EAAE,EAAE,gBAAgB,WAEjB,MAAM,WAAW,EAAE,YAAY,CAAC,sBAiBtD;AAED,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAC3D,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,EAAE,gBAAgB,EAAE,EAAE,gBAAgB,GACrC,MAAM,OAAO,CAAC,eAAe,CAAC,CAUhC;AAED,8BAAsB,cAAc,CAClC,WAAW,GAAG,SAAS,EACvB,YAAY,GAAG,IAAI;IAEnB,aAAoB,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAAC;aAE7C,gBAAgB,IAAI,cAAc,CAAC,WAAW,EAAE,YAAY,CAAC;IAE7E,IACW,SAAS,IAAI,cAAc,CAAC,WAAW,EAAE,YAAY,CAAC,CAYhE;CACF;AAED,MAAM,WAAW,kBAAkB,CACjC,WAAW,GAAG,SAAS,EACvB,YAAY,GAAG,IAAI;IAEnB,cAAc,EAAE,cAAc,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;CAC3D"}

package/dist/zkProgrammable/ZkProgrammable.js

@@ -0,0 +1,60 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Memoize } from "typescript-memoize";
+import { mockProof } from "./provableMethod";
+const errors = {
+    appChainNotSet: (name) => new Error(`Appchain was not injected for: ${name}`),
+};
+export function verifyToMockable(verify, { areProofsEnabled }) {
+    return async (proof) => {
+        if (areProofsEnabled) {
+            let verified = false;
+            try {
+                verified = await verify(proof);
+            }
+            catch (error) {
+                // silently fail verification
+                console.error(error);
+                verified = false;
+            }
+            return verified;
+        }
+        return proof.proof === mockProof;
+    };
+}
+export const mockVerificationKey = "mock-verification-key";
+export function compileToMockable(compile, { areProofsEnabled }) {
+    return async () => {
+        if (areProofsEnabled) {
+            return await compile();
+        }
+        return {
+            verificationKey: mockVerificationKey,
+        };
+    };
+}
+export class ZkProgrammable {
+    get zkProgram() {
+        const zkProgram = this.zkProgramFactory();
+        if (!this.appChain) {
+            throw errors.appChainNotSet(this.constructor.name);
+        }
+        return {
+            ...zkProgram,
+            verify: verifyToMockable(zkProgram.verify, this.appChain),
+            compile: compileToMockable(zkProgram.compile, this.appChain),
+        };
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], ZkProgrammable.prototype, "zkProgram", null);

package/dist/zkProgrammable/provableMethod.d.ts

@@ -0,0 +1,16 @@
+import { ProvableMethodExecutionContext } from "./ProvableMethodExecutionContext";
+import type { ZkProgrammable } from "./ZkProgrammable";
+export type DecoratedMethod = (...args: unknown[]) => unknown;
+export declare const mockProof = "mock-proof";
+export declare function toProver(methodName: string, simulatedMethod: DecoratedMethod, isFirstParameterPublicInput: boolean, ...args: unknown[]): (this: ZkProgrammable<any, any>) => Promise<import("snarkyjs/dist/node/lib/proof_system").Proof<any, any>>;
+/**
+ * Decorates a provable method on a 'prover class', depending on
+ * if proofs are enabled or not, either runs the respective zkProgram prover,
+ * or simulates the method execution and issues a mock proof.
+ *
+ * @param isFirstParameterPublicInput
+ * @param executionContext
+ * @returns
+ */
+export declare function provableMethod(isFirstParameterPublicInput?: boolean, executionContext?: ProvableMethodExecutionContext): <Target extends ZkProgrammable<any, any>>(target: Target, methodName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+//# sourceMappingURL=provableMethod.d.ts.map

package/dist/zkProgrammable/provableMethod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provableMethod.d.ts","sourceRoot":"","sources":["../../src/zkProgrammable/provableMethod.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;AAE9D,eAAO,MAAM,SAAS,eAAe,CAAC;AAEtC,wBAAgB,QAAQ,CACtB,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,eAAe,EAChC,2BAA2B,EAAE,OAAO,EACpC,GAAG,IAAI,EAAE,OAAO,EAAE,UAGiB,eAAe,GAAG,EAAE,GAAG,CAAC,4EAyB5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,2BAA2B,UAAO,EAClC,gBAAgB,GAAE,8BAEjB,yEAKa,MAAM,cACN,kBAAkB,wBA4CjC"}

package/dist/zkProgrammable/provableMethod.js

@@ -0,0 +1,69 @@
+import { container } from "tsyringe";
+import { ProvableMethodExecutionContext } from "./ProvableMethodExecutionContext";
+export const mockProof = "mock-proof";
+export function toProver(methodName, simulatedMethod, isFirstParameterPublicInput, ...args) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return async function prover() {
+        const areProofsEnabled = this.appChain?.areProofsEnabled;
+        if (areProofsEnabled ?? false) {
+            const programProvableMethod = this.zkProgram.methods[methodName];
+            return await Reflect.apply(programProvableMethod, this, args);
+        }
+        // create a mock proof by simulating method execution in JS
+        const publicOutput = Reflect.apply(simulatedMethod, this, args);
+        return new this.zkProgram.Proof({
+            proof: mockProof,
+            // eslint-disable-next-line no-warning-comments
+            // TODO: provide undefined if public input is not used
+            publicInput: isFirstParameterPublicInput ? args[0] : undefined,
+            publicOutput,
+            /**
+             * We set this to the max possible number, to avoid having
+             * to manually count in-circuit proof verifications
+             */
+            maxProofsVerified: 2,
+        });
+    };
+}
+/**
+ * Decorates a provable method on a 'prover class', depending on
+ * if proofs are enabled or not, either runs the respective zkProgram prover,
+ * or simulates the method execution and issues a mock proof.
+ *
+ * @param isFirstParameterPublicInput
+ * @param executionContext
+ * @returns
+ */
+export function provableMethod(isFirstParameterPublicInput = true, executionContext = container.resolve(ProvableMethodExecutionContext)) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (target, methodName, descriptor) => {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const simulatedMethod = descriptor.value;
+        descriptor.value = function value(...args) {
+            const prover = toProver(methodName, simulatedMethod, isFirstParameterPublicInput, ...args);
+            executionContext.beforeMethod(this.constructor.name, methodName, args);
+            /**
+             * Check if the method is called at the top level,
+             * if yes then create a prover.
+             */
+            if (executionContext.isTopLevel) {
+                executionContext.setProver(prover.bind(this));
+            }
+            /**
+             * Regardless of if the method is called from the top level
+             * or not, execute its simulated (Javascript) version and
+             * return the result.
+             */
+            // eslint-disable-next-line @typescript-eslint/init-declarations
+            let result;
+            try {
+                result = Reflect.apply(simulatedMethod, this, args);
+            }
+            finally {
+                executionContext.afterMethod();
+            }
+            return result;
+        };
+        return descriptor;
+    };
+}

package/jest.config.cjs

@@ -0,0 +1 @@
+module.exports = require("../../jest.config.cjs");

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@proto-kit/common",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "version": "0.1.1-develop.153+10a7974",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "lint": "eslint ./src ./test",
+    "test:file": "node --experimental-vm-modules --experimental-wasm-modules --experimental-wasm-threads ../../node_modules/jest/bin/jest.js",
+    "test": "npm run test:file -- ./src/** ./test/**",
+    "test:watch": "npm run test:file -- ./src/** ./test/** --watch"
+  },
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "loglevel": "^1.8.1",
+    "reflect-metadata": "^0.1.13",
+    "tsyringe": "^4.7.0",
+    "typescript-memoize": "^1.1.1"
+  },
+  "peerDependencies": {
+    "snarkyjs": "0.11.0",
+    "tsyringe": "^4.7.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/lodash": "^4.14.194"
+  },
+  "gitHead": "10a7974582f79be6f4f099eec83c4b0359cce2a6"
+}