@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.0b941701

package/dest/public/public_tx_simulator/telemetry_public_tx_simulator.js

@@ -0,0 +1,415 @@
+function applyDecs2203RFactory() {
+    function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+        return function addInitializer(initializer) {
+            assertNotFinished(decoratorFinishedRef, "addInitializer");
+            assertCallable(initializer, "An initializer");
+            initializers.push(initializer);
+        };
+    }
+    function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+        var kindStr;
+        switch(kind){
+            case 1:
+                kindStr = "accessor";
+                break;
+            case 2:
+                kindStr = "method";
+                break;
+            case 3:
+                kindStr = "getter";
+                break;
+            case 4:
+                kindStr = "setter";
+                break;
+            default:
+                kindStr = "field";
+        }
+        var ctx = {
+            kind: kindStr,
+            name: isPrivate ? "#" + name : name,
+            static: isStatic,
+            private: isPrivate,
+            metadata: metadata
+        };
+        var decoratorFinishedRef = {
+            v: false
+        };
+        ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+        var get, set;
+        if (kind === 0) {
+            if (isPrivate) {
+                get = desc.get;
+                set = desc.set;
+            } else {
+                get = function() {
+                    return this[name];
+                };
+                set = function(v) {
+                    this[name] = v;
+                };
+            }
+        } else if (kind === 2) {
+            get = function() {
+                return desc.value;
+            };
+        } else {
+            if (kind === 1 || kind === 3) {
+                get = function() {
+                    return desc.get.call(this);
+                };
+            }
+            if (kind === 1 || kind === 4) {
+                set = function(v) {
+                    desc.set.call(this, v);
+                };
+            }
+        }
+        ctx.access = get && set ? {
+            get: get,
+            set: set
+        } : get ? {
+            get: get
+        } : {
+            set: set
+        };
+        try {
+            return dec(value, ctx);
+        } finally{
+            decoratorFinishedRef.v = true;
+        }
+    }
+    function assertNotFinished(decoratorFinishedRef, fnName) {
+        if (decoratorFinishedRef.v) {
+            throw new Error("attempted to call " + fnName + " after decoration was finished");
+        }
+    }
+    function assertCallable(fn, hint) {
+        if (typeof fn !== "function") {
+            throw new TypeError(hint + " must be a function");
+        }
+    }
+    function assertValidReturnValue(kind, value) {
+        var type = typeof value;
+        if (kind === 1) {
+            if (type !== "object" || value === null) {
+                throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+            }
+            if (value.get !== undefined) {
+                assertCallable(value.get, "accessor.get");
+            }
+            if (value.set !== undefined) {
+                assertCallable(value.set, "accessor.set");
+            }
+            if (value.init !== undefined) {
+                assertCallable(value.init, "accessor.init");
+            }
+        } else if (type !== "function") {
+            var hint;
+            if (kind === 0) {
+                hint = "field";
+            } else if (kind === 10) {
+                hint = "class";
+            } else {
+                hint = "method";
+            }
+            throw new TypeError(hint + " decorators must return a function or void 0");
+        }
+    }
+    function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+        var decs = decInfo[0];
+        var desc, init, value;
+        if (isPrivate) {
+            if (kind === 0 || kind === 1) {
+                desc = {
+                    get: decInfo[3],
+                    set: decInfo[4]
+                };
+            } else if (kind === 3) {
+                desc = {
+                    get: decInfo[3]
+                };
+            } else if (kind === 4) {
+                desc = {
+                    set: decInfo[3]
+                };
+            } else {
+                desc = {
+                    value: decInfo[3]
+                };
+            }
+        } else if (kind !== 0) {
+            desc = Object.getOwnPropertyDescriptor(base, name);
+        }
+        if (kind === 1) {
+            value = {
+                get: desc.get,
+                set: desc.set
+            };
+        } else if (kind === 2) {
+            value = desc.value;
+        } else if (kind === 3) {
+            value = desc.get;
+        } else if (kind === 4) {
+            value = desc.set;
+        }
+        var newValue, get, set;
+        if (typeof decs === "function") {
+            newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (newValue !== void 0) {
+                assertValidReturnValue(kind, newValue);
+                if (kind === 0) {
+                    init = newValue;
+                } else if (kind === 1) {
+                    init = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else {
+                    value = newValue;
+                }
+            }
+        } else {
+            for(var i = decs.length - 1; i >= 0; i--){
+                var dec = decs[i];
+                newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                if (newValue !== void 0) {
+                    assertValidReturnValue(kind, newValue);
+                    var newInit;
+                    if (kind === 0) {
+                        newInit = newValue;
+                    } else if (kind === 1) {
+                        newInit = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+                        value = {
+                            get: get,
+                            set: set
+                        };
+                    } else {
+                        value = newValue;
+                    }
+                    if (newInit !== void 0) {
+                        if (init === void 0) {
+                            init = newInit;
+                        } else if (typeof init === "function") {
+                            init = [
+                                init,
+                                newInit
+                            ];
+                        } else {
+                            init.push(newInit);
+                        }
+                    }
+                }
+            }
+        }
+        if (kind === 0 || kind === 1) {
+            if (init === void 0) {
+                init = function(instance, init) {
+                    return init;
+                };
+            } else if (typeof init !== "function") {
+                var ownInitializers = init;
+                init = function(instance, init) {
+                    var value = init;
+                    for(var i = 0; i < ownInitializers.length; i++){
+                        value = ownInitializers[i].call(instance, value);
+                    }
+                    return value;
+                };
+            } else {
+                var originalInitializer = init;
+                init = function(instance, init) {
+                    return originalInitializer.call(instance, init);
+                };
+            }
+            ret.push(init);
+        }
+        if (kind !== 0) {
+            if (kind === 1) {
+                desc.get = value.get;
+                desc.set = value.set;
+            } else if (kind === 2) {
+                desc.value = value;
+            } else if (kind === 3) {
+                desc.get = value;
+            } else if (kind === 4) {
+                desc.set = value;
+            }
+            if (isPrivate) {
+                if (kind === 1) {
+                    ret.push(function(instance, args) {
+                        return value.get.call(instance, args);
+                    });
+                    ret.push(function(instance, args) {
+                        return value.set.call(instance, args);
+                    });
+                } else if (kind === 2) {
+                    ret.push(value);
+                } else {
+                    ret.push(function(instance, args) {
+                        return value.call(instance, args);
+                    });
+                }
+            } else {
+                Object.defineProperty(base, name, desc);
+            }
+        }
+    }
+    function applyMemberDecs(Class, decInfos, metadata) {
+        var ret = [];
+        var protoInitializers;
+        var staticInitializers;
+        var existingProtoNonFields = new Map();
+        var existingStaticNonFields = new Map();
+        for(var i = 0; i < decInfos.length; i++){
+            var decInfo = decInfos[i];
+            if (!Array.isArray(decInfo)) continue;
+            var kind = decInfo[1];
+            var name = decInfo[2];
+            var isPrivate = decInfo.length > 3;
+            var isStatic = kind >= 5;
+            var base;
+            var initializers;
+            if (isStatic) {
+                base = Class;
+                kind = kind - 5;
+                staticInitializers = staticInitializers || [];
+                initializers = staticInitializers;
+            } else {
+                base = Class.prototype;
+                protoInitializers = protoInitializers || [];
+                initializers = protoInitializers;
+            }
+            if (kind !== 0 && !isPrivate) {
+                var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                var existingKind = existingNonFields.get(name) || 0;
+                if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) {
+                    throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                } else if (!existingKind && kind > 2) {
+                    existingNonFields.set(name, kind);
+                } else {
+                    existingNonFields.set(name, true);
+                }
+            }
+            applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+        }
+        pushInitializers(ret, protoInitializers);
+        pushInitializers(ret, staticInitializers);
+        return ret;
+    }
+    function pushInitializers(ret, initializers) {
+        if (initializers) {
+            ret.push(function(instance) {
+                for(var i = 0; i < initializers.length; i++){
+                    initializers[i].call(instance);
+                }
+                return instance;
+            });
+        }
+    }
+    function applyClassDecs(targetClass, classDecs, metadata) {
+        if (classDecs.length > 0) {
+            var initializers = [];
+            var newClass = targetClass;
+            var name = targetClass.name;
+            for(var i = classDecs.length - 1; i >= 0; i--){
+                var decoratorFinishedRef = {
+                    v: false
+                };
+                try {
+                    var nextNewClass = classDecs[i](newClass, {
+                        kind: "class",
+                        name: name,
+                        addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                        metadata
+                    });
+                } finally{
+                    decoratorFinishedRef.v = true;
+                }
+                if (nextNewClass !== undefined) {
+                    assertValidReturnValue(10, nextNewClass);
+                    newClass = nextNewClass;
+                }
+            }
+            return [
+                defineMetadata(newClass, metadata),
+                function() {
+                    for(var i = 0; i < initializers.length; i++){
+                        initializers[i].call(newClass);
+                    }
+                }
+            ];
+        }
+    }
+    function defineMetadata(Class, metadata) {
+        return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+            configurable: true,
+            enumerable: true,
+            value: metadata
+        });
+    }
+    return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+        if (parentClass !== void 0) {
+            var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+        }
+        var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+        var e = applyMemberDecs(targetClass, memberDecs, metadata);
+        if (!classDecs.length) defineMetadata(targetClass, metadata);
+        return {
+            e: e,
+            get c () {
+                return applyClassDecs(targetClass, classDecs, metadata);
+            }
+        };
+    };
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+    return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _dec1, _initProto;
+import { TxExecutionPhase } from '@aztec/stdlib/tx';
+import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { ExecutorMetrics } from '../executor_metrics.js';
+import { MeasuredPublicTxSimulator } from './measured_public_tx_simulator.js';
+_dec = trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, callRequest)=>({
+        [Attributes.TX_HASH]: context.txHash.toString(),
+        [Attributes.TARGET_ADDRESS]: callRequest.request.contractAddress.toString(),
+        [Attributes.SENDER_ADDRESS]: callRequest.request.msgSender.toString(),
+        [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString()
+    })), _dec1 = trackSpan('PublicTxSimulator.simulateEnqueuedCallInternal', (_stateManager, _callRequest, _allocatedGas, _transactionFee, fnName)=>({
+        [Attributes.APP_CIRCUIT_NAME]: fnName
+    }));
+/**
+ * A public tx simulator that tracks runtime/production metrics with telemetry.
+ */ export class TelemetryPublicTxSimulator extends MeasuredPublicTxSimulator {
+    static{
+        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                2,
+                "simulateEnqueuedCall"
+            ],
+            [
+                _dec1,
+                2,
+                "simulateEnqueuedCallInternal"
+            ]
+        ], []));
+    }
+    /* tracer needed by trackSpans */ tracer;
+    constructor(merkleTree, contractsDB, globalVariables, telemetryClient = getTelemetryClient(), config){
+        const metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
+        super(merkleTree, contractsDB, globalVariables, metrics, config), _initProto(this);
+        this.tracer = metrics.tracer;
+    }
+    async simulateEnqueuedCall(phase, context, callRequest) {
+        return await super.simulateEnqueuedCall(phase, context, callRequest);
+    }
+    async simulateEnqueuedCallInternal(stateManager, callRequest, allocatedGas, transactionFee, fnName) {
+        return await super.simulateEnqueuedCallInternal(stateManager, callRequest, allocatedGas, transactionFee, fnName);
+    }
+}

package/dest/public/side_effect_errors.d.ts

@@ -1,4 +1,44 @@
-export declare class SideEffectLimitReachedError extends Error {
+import { CheckedPublicExecutionError } from './public_errors.js';
+/**
+ * Any error that can be thrown during side effect insertion in public.
+ * Includes SideEffectLimitReachedError and NullifierCollisionError.
+ */
+export declare abstract class SideEffectError extends CheckedPublicExecutionError {
+    constructor(message: string);
+}
+export declare class SideEffectLimitReachedError extends SideEffectError {
     constructor(sideEffectType: string, limit: number);
 }
-//# sourceMappingURL=side_effect_errors.d.ts.map
+export declare class MaxCallsToUniqueContractClassIdsError extends SideEffectLimitReachedError {
+    constructor();
+}
+export declare class NullifierLimitReachedError extends SideEffectLimitReachedError {
+    constructor();
+}
+export declare class NoteHashLimitReachedError extends SideEffectLimitReachedError {
+    constructor();
+}
+export declare class L2ToL1MessageLimitReachedError extends SideEffectLimitReachedError {
+    constructor();
+}
+export declare class NullifierCollisionError extends SideEffectError {
+    constructor(message: string);
+}
+/**
+ * Any error that can be thrown during side effect reads in public.
+ * Note: Thrown at state manager level and unknown by simulation, hence NOT considered
+ * CheckedPublicExecutionErrors. Currently only includes append-only tree reads.
+ */
+export declare abstract class SideEffectReadError extends Error {
+    constructor(message: string);
+}
+export declare class IndexOutOfRangeError extends SideEffectReadError {
+    constructor(tree: string, index: number, limit: number);
+}
+export declare class NoteHashIndexOutOfRangeError extends IndexOutOfRangeError {
+    constructor(index: number);
+}
+export declare class L1ToL2MessageIndexOutOfRangeError extends IndexOutOfRangeError {
+    constructor(index: number);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lkZV9lZmZlY3RfZXJyb3JzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHVibGljL3NpZGVfZWZmZWN0X2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFTQSxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVqRTs7O0dBR0c7QUFDSCw4QkFBc0IsZUFBZ0IsU0FBUSwyQkFBMkI7SUFDdkUsWUFBWSxPQUFPLEVBQUUsTUFBTSxFQUcxQjtDQUNGO0FBRUQscUJBQWEsMkJBQTRCLFNBQVEsZUFBZTtJQUM5RCxZQUFZLGNBQWMsRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFHaEQ7Q0FDRjtBQUVELHFCQUFhLHFDQUFzQyxTQUFRLDJCQUEyQjtJQUNwRixjQUdDO0NBQ0Y7QUFFRCxxQkFBYSwwQkFBMkIsU0FBUSwyQkFBMkI7SUFDekUsY0FHQztDQUNGO0FBRUQscUJBQWEseUJBQTBCLFNBQVEsMkJBQTJCO0lBQ3hFLGNBR0M7Q0FDRjtBQUVELHFCQUFhLDhCQUErQixTQUFRLDJCQUEyQjtJQUM3RSxjQUdDO0NBQ0Y7QUFFRCxxQkFBYSx1QkFBd0IsU0FBUSxlQUFlO0lBQzFELFlBQVksT0FBTyxFQUFFLE1BQU0sRUFHMUI7Q0FDRjtBQUVEOzs7O0dBSUc7QUFDSCw4QkFBc0IsbUJBQW9CLFNBQVEsS0FBSztJQUNyRCxZQUFZLE9BQU8sRUFBRSxNQUFNLEVBRzFCO0NBQ0Y7QUFFRCxxQkFBYSxvQkFBcUIsU0FBUSxtQkFBbUI7SUFDM0QsWUFBWSxJQUFJLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFHckQ7Q0FDRjtBQUVELHFCQUFhLDRCQUE2QixTQUFRLG9CQUFvQjtJQUNwRSxZQUFZLEtBQUssRUFBRSxNQUFNLEVBR3hCO0NBQ0Y7QUFFRCxxQkFBYSxpQ0FBa0MsU0FBUSxvQkFBb0I7SUFDekUsWUFBWSxLQUFLLEVBQUUsTUFBTSxFQUd4QjtDQUNGIn0=

package/dest/public/side_effect_errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"side_effect_errors.d.ts","sourceRoot":"","sources":["../../src/public/side_effect_errors.ts"],"names":[],"mappings":"AAAA,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAIlD"}
+{"version":3,"file":"side_effect_errors.d.ts","sourceRoot":"","sources":["../../src/public/side_effect_errors.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEjE;;;GAGG;AACH,8BAAsB,eAAgB,SAAQ,2BAA2B;IACvE,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,qBAAa,2BAA4B,SAAQ,eAAe;IAC9D,YAAY,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAGhD;CACF;AAED,qBAAa,qCAAsC,SAAQ,2BAA2B;IACpF,cAGC;CACF;AAED,qBAAa,0BAA2B,SAAQ,2BAA2B;IACzE,cAGC;CACF;AAED,qBAAa,yBAA0B,SAAQ,2BAA2B;IACxE,cAGC;CACF;AAED,qBAAa,8BAA+B,SAAQ,2BAA2B;IAC7E,cAGC;CACF;AAED,qBAAa,uBAAwB,SAAQ,eAAe;IAC1D,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;GAIG;AACH,8BAAsB,mBAAoB,SAAQ,KAAK;IACrD,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,qBAAa,oBAAqB,SAAQ,mBAAmB;IAC3D,YAAY,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAGrD;CACF;AAED,qBAAa,4BAA6B,SAAQ,oBAAoB;IACpE,YAAY,KAAK,EAAE,MAAM,EAGxB;CACF;AAED,qBAAa,iCAAkC,SAAQ,oBAAoB;IACzE,YAAY,KAAK,EAAE,MAAM,EAGxB;CACF"}

package/dest/public/side_effect_errors.js

@@ -1,6 +1,75 @@
-export class SideEffectLimitReachedError extends Error {
+import { L1_TO_L2_MSG_TREE_LEAF_COUNT, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS, NOTE_HASH_TREE_LEAF_COUNT } from '@aztec/constants';
+import { CheckedPublicExecutionError } from './public_errors.js';
+/**
+ * Any error that can be thrown during side effect insertion in public.
+ * Includes SideEffectLimitReachedError and NullifierCollisionError.
+ */ export class SideEffectError extends CheckedPublicExecutionError {
+    constructor(message){
+        super(message);
+        this.name = 'SideEffectInsertionError';
+    }
+}
+export class SideEffectLimitReachedError extends SideEffectError {
     constructor(sideEffectType, limit){
         super(`Reached the limit (${limit}) on number of '${sideEffectType}' per tx`);
         this.name = 'SideEffectLimitReachedError';
     }
 }
+export class MaxCallsToUniqueContractClassIdsError extends SideEffectLimitReachedError {
+    constructor(){
+        super('contract calls to unique class IDs', MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS);
+        this.name = 'MaxCallsToUniqueContractClassIdsError';
+    }
+}
+export class NullifierLimitReachedError extends SideEffectLimitReachedError {
+    constructor(){
+        super('nullifier', MAX_NULLIFIERS_PER_TX);
+        this.name = 'NullifierLimitReachedError';
+    }
+}
+export class NoteHashLimitReachedError extends SideEffectLimitReachedError {
+    constructor(){
+        super('note hash', MAX_NOTE_HASHES_PER_TX);
+        this.name = 'NoteHashLimitReachedError';
+    }
+}
+export class L2ToL1MessageLimitReachedError extends SideEffectLimitReachedError {
+    constructor(){
+        super('l2 to l1 message', MAX_L2_TO_L1_MSGS_PER_TX);
+        this.name = 'L2ToL1MessageLimitReachedError';
+    }
+}
+export class NullifierCollisionError extends SideEffectError {
+    constructor(message){
+        super(`Nullifier collision: ${message}`);
+        this.name = 'NullifierCollisionError';
+    }
+}
+/**
+ * Any error that can be thrown during side effect reads in public.
+ * Note: Thrown at state manager level and unknown by simulation, hence NOT considered
+ * CheckedPublicExecutionErrors. Currently only includes append-only tree reads.
+ */ export class SideEffectReadError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'SideEffectReadError';
+    }
+}
+export class IndexOutOfRangeError extends SideEffectReadError {
+    constructor(tree, index, limit){
+        super(`Attempting to read index ${index} of ${tree} tree with maximum ${limit} leaves`);
+        this.name = 'IndexOutOfRangeError';
+    }
+}
+export class NoteHashIndexOutOfRangeError extends IndexOutOfRangeError {
+    constructor(index){
+        super('note hash', index, NOTE_HASH_TREE_LEAF_COUNT);
+        this.name = 'NoteHashIndexOutOfRangeError';
+    }
+}
+export class L1ToL2MessageIndexOutOfRangeError extends IndexOutOfRangeError {
+    constructor(index){
+        super('l1 to l2 message', index, L1_TO_L2_MSG_TREE_LEAF_COUNT);
+        this.name = 'L1ToL2MessageIndexOutOfRangeError';
+    }
+}