@aztec/simulator 0.0.0-test.0

package/dest/public/avm/opcodes/arithmetic.d.ts

@@ -0,0 +1,37 @@
+import type { AvmContext } from '../avm_context.js';
+import { type Field, type MemoryValue, type TaggedMemoryInterface } from '../avm_memory_types.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+export declare abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
+    execute(context: AvmContext): Promise<void>;
+    protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;
+    protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number): void;
+}
+export declare class Add extends ThreeOperandArithmeticInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.ADD_8;
+    protected compute(a: MemoryValue, b: MemoryValue): MemoryValue;
+}
+export declare class Sub extends ThreeOperandArithmeticInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.SUB_8;
+    protected compute(a: MemoryValue, b: MemoryValue): MemoryValue;
+}
+export declare class Mul extends ThreeOperandArithmeticInstruction {
+    static type: string;
+    static readonly opcode = Opcode.MUL_8;
+    protected compute(a: MemoryValue, b: MemoryValue): MemoryValue;
+}
+export declare class Div extends ThreeOperandArithmeticInstruction {
+    static type: string;
+    static readonly opcode = Opcode.DIV_8;
+    protected compute(a: MemoryValue, b: MemoryValue): MemoryValue;
+    protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number): void;
+}
+export declare class FieldDiv extends ThreeOperandArithmeticInstruction {
+    static type: string;
+    static readonly opcode = Opcode.FDIV_8;
+    protected compute(a: Field, b: Field): Field;
+    protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number): void;
+}
+//# sourceMappingURL=arithmetic.d.ts.map

package/dest/public/avm/opcodes/arithmetic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmetic.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/arithmetic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EACL,KAAK,KAAK,EACV,KAAK,WAAW,EAEhB,KAAK,qBAAqB,EAE3B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,MAAM,EAAE,MAAM,+CAA+C,CAAC;AAEvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,8BAAsB,iCAAkC,SAAQ,uBAAuB;IACxE,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxD,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW;IACvE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAGpF;AAED,qBAAa,GAAI,SAAQ,iCAAiC;IACxD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAEtC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW;CAG/D;AAED,qBAAa,GAAI,SAAQ,iCAAiC;IACxD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAEtC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW;CAG/D;AAED,qBAAa,GAAI,SAAQ,iCAAiC;IACxD,MAAM,CAAC,IAAI,EAAE,MAAM,CAAS;IAC5B,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAEtC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW;CAG/D;AAED,qBAAa,GAAI,SAAQ,iCAAiC;IACxD,MAAM,CAAC,IAAI,EAAE,MAAM,CAAS;IAC5B,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAEtC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,WAAW;cAQ3C,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI7F;AAED,qBAAa,QAAS,SAAQ,iCAAiC;IAC7D,MAAM,CAAC,IAAI,EAAE,MAAM,CAAU;IAC7B,MAAM,CAAC,QAAQ,CAAC,MAAM,iBAAiB;IAEvC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK;cAKzB,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI7F"}

package/dest/public/avm/opcodes/arithmetic.js

@@ -0,0 +1,73 @@
+import { TaggedMemory, TypeTag } from '../avm_memory_types.js';
+import { ArithmeticError } from '../errors.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+export class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.aOffset,
+            this.bOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
+        this.checkTags(memory, aOffset, bOffset);
+        const a = memory.get(aOffset);
+        const b = memory.get(bOffset);
+        const dest = this.compute(a, b);
+        memory.set(dstOffset, dest);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        memory.checkTagsAreSame(aOffset, bOffset);
+    }
+}
+export class Add extends ThreeOperandArithmeticInstruction {
+    static type = 'ADD';
+    static opcode = Opcode.ADD_8;
+    compute(a, b) {
+        return a.add(b);
+    }
+}
+export class Sub extends ThreeOperandArithmeticInstruction {
+    static type = 'SUB';
+    static opcode = Opcode.SUB_8;
+    compute(a, b) {
+        return a.sub(b);
+    }
+}
+export class Mul extends ThreeOperandArithmeticInstruction {
+    static type = 'MUL';
+    static opcode = Opcode.MUL_8;
+    compute(a, b) {
+        return a.mul(b);
+    }
+}
+export class Div extends ThreeOperandArithmeticInstruction {
+    static type = 'DIV';
+    static opcode = Opcode.DIV_8;
+    compute(a, b) {
+        if (b.toBigInt() === 0n) {
+            throw new ArithmeticError('Division by zero');
+        }
+        return a.div(b);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        memory.checkTagsAreSame(aOffset, bOffset);
+        TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset)); // Follows that bOffset tag is also of integral type
+    }
+}
+export class FieldDiv extends ThreeOperandArithmeticInstruction {
+    static type = 'FDIV';
+    static opcode = Opcode.FDIV_8;
+    compute(a, b) {
+        // return (a as Field).fdiv(b as Field);
+        return a.fdiv(b);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        memory.checkTagsAreSame(aOffset, bOffset);
+        memory.checkTag(TypeTag.FIELD, aOffset); // Follows that bOffset has also tag of type Field
+    }
+}

package/dest/public/avm/opcodes/bitwise.d.ts

@@ -0,0 +1,50 @@
+import type { AvmContext } from '../avm_context.js';
+import { type IntegralValue, type TaggedMemoryInterface } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+declare abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
+    execute(context: AvmContext): Promise<void>;
+    protected abstract compute(a: IntegralValue, b: IntegralValue): IntegralValue;
+    protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number): void;
+}
+export declare class And extends ThreeOperandBitwiseInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.AND_8;
+    protected compute(a: IntegralValue, b: IntegralValue): IntegralValue;
+}
+export declare class Or extends ThreeOperandBitwiseInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.OR_8;
+    protected compute(a: IntegralValue, b: IntegralValue): IntegralValue;
+}
+export declare class Xor extends ThreeOperandBitwiseInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.XOR_8;
+    protected compute(a: IntegralValue, b: IntegralValue): IntegralValue;
+}
+export declare class Shl extends ThreeOperandBitwiseInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.SHL_8;
+    protected compute(a: IntegralValue, b: IntegralValue): IntegralValue;
+    protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number): void;
+}
+export declare class Shr extends ThreeOperandBitwiseInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.SHR_8;
+    protected compute(a: IntegralValue, b: IntegralValue): IntegralValue;
+    protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number): void;
+}
+export declare class Not extends Instruction {
+    private indirect;
+    private srcOffset;
+    private dstOffset;
+    static readonly type: string;
+    static readonly opcode = Opcode.NOT_8;
+    static readonly wireFormat8: OperandType[];
+    static readonly wireFormat16: OperandType[];
+    constructor(indirect: number, srcOffset: number, dstOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+export {};
+//# sourceMappingURL=bitwise.d.ts.map

package/dest/public/avm/opcodes/bitwise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitwise.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/bitwise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,aAAa,EAAgB,KAAK,qBAAqB,EAAW,MAAM,wBAAwB,CAAC;AAC/G,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,uBAAe,8BAA+B,SAAQ,uBAAuB;IAC9D,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxD,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;IAC7E,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAIpF;AAED,qBAAa,GAAI,SAAQ,8BAA8B;IACrD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;cAEnB,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;CAG9E;AAED,qBAAa,EAAG,SAAQ,8BAA8B;IACpD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAQ;IACpC,MAAM,CAAC,QAAQ,CAAC,MAAM,eAAe;cAElB,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;CAG9E;AAED,qBAAa,GAAI,SAAQ,8BAA8B;IACrD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;cAEnB,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;CAG9E;AAED,qBAAa,GAAI,SAAQ,8BAA8B;IACrD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;cAEnB,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;cAG1D,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI7F;AAED,qBAAa,GAAI,SAAQ,8BAA8B;IACrD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;cAEnB,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa;cAG1D,SAAS,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI7F;AAED,qBAAa,GAAI,SAAQ,WAAW;IAOtB,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,SAAS;IAAU,OAAO,CAAC,SAAS;IANlF,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAEtC,MAAM,CAAC,QAAQ,CAAC,WAAW,gBAAgF;IAC3G,MAAM,CAAC,QAAQ,CAAC,YAAY,gBAAkF;gBAE1F,QAAQ,EAAE,MAAM,EAAU,SAAS,EAAE,MAAM,EAAU,SAAS,EAAE,MAAM;IAI7E,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAazD"}

package/dest/public/avm/opcodes/bitwise.js

@@ -0,0 +1,106 @@
+import { TaggedMemory, TypeTag } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.aOffset,
+            this.bOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
+        this.checkTags(memory, aOffset, bOffset);
+        const a = memory.getAs(aOffset);
+        const b = memory.getAs(bOffset);
+        const res = this.compute(a, b);
+        memory.set(dstOffset, res);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
+        memory.checkTagsAreSame(aOffset, bOffset);
+    }
+}
+export class And extends ThreeOperandBitwiseInstruction {
+    static type = 'AND';
+    static opcode = Opcode.AND_8;
+    compute(a, b) {
+        return a.and(b);
+    }
+}
+export class Or extends ThreeOperandBitwiseInstruction {
+    static type = 'OR';
+    static opcode = Opcode.OR_8;
+    compute(a, b) {
+        return a.or(b);
+    }
+}
+export class Xor extends ThreeOperandBitwiseInstruction {
+    static type = 'XOR';
+    static opcode = Opcode.XOR_8;
+    compute(a, b) {
+        return a.xor(b);
+    }
+}
+export class Shl extends ThreeOperandBitwiseInstruction {
+    static type = 'SHL';
+    static opcode = Opcode.SHL_8;
+    compute(a, b) {
+        return a.shl(b);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
+        memory.checkTag(TypeTag.UINT8, bOffset);
+    }
+}
+export class Shr extends ThreeOperandBitwiseInstruction {
+    static type = 'SHR';
+    static opcode = Opcode.SHR_8;
+    compute(a, b) {
+        return a.shr(b);
+    }
+    checkTags(memory, aOffset, bOffset) {
+        TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
+        memory.checkTag(TypeTag.UINT8, bOffset);
+    }
+}
+export class Not extends Instruction {
+    indirect;
+    srcOffset;
+    dstOffset;
+    static type = 'NOT';
+    static opcode = Opcode.NOT_8;
+    static wireFormat8 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8
+    ];
+    static wireFormat16 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, srcOffset, dstOffset){
+        super(), this.indirect = indirect, this.srcOffset = srcOffset, this.dstOffset = dstOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.srcOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
+        TaggedMemory.checkIsIntegralTag(memory.getTag(srcOffset));
+        const value = memory.getAs(srcOffset);
+        const res = value.not();
+        memory.set(dstOffset, res);
+    }
+}

package/dest/public/avm/opcodes/comparators.d.ts

@@ -0,0 +1,25 @@
+import type { AvmContext } from '../avm_context.js';
+import { type MemoryValue } from '../avm_memory_types.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+declare abstract class ComparatorInstruction extends ThreeOperandInstruction {
+    execute(context: AvmContext): Promise<void>;
+    protected abstract compare(a: MemoryValue, b: MemoryValue): boolean;
+}
+export declare class Eq extends ComparatorInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.EQ_8;
+    protected compare(a: MemoryValue, b: MemoryValue): boolean;
+}
+export declare class Lt extends ComparatorInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.LT_8;
+    protected compare(a: MemoryValue, b: MemoryValue): boolean;
+}
+export declare class Lte extends ComparatorInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.LTE_8;
+    protected compare(a: MemoryValue, b: MemoryValue): boolean;
+}
+export {};
+//# sourceMappingURL=comparators.d.ts.map

package/dest/public/avm/opcodes/comparators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparators.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/comparators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,WAAW,EAAS,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,+CAA+C,CAAC;AAEvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,uBAAe,qBAAsB,SAAQ,uBAAuB;IACrD,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxD,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO;CACpE;AAED,qBAAa,EAAG,SAAQ,qBAAqB;IAC3C,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAQ;IACpC,MAAM,CAAC,QAAQ,CAAC,MAAM,eAAe;IAErC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO;CAG3D;AAED,qBAAa,EAAG,SAAQ,qBAAqB;IAC3C,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAQ;IACpC,MAAM,CAAC,QAAQ,CAAC,MAAM,eAAe;IAErC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO;CAG3D;AAED,qBAAa,GAAI,SAAQ,qBAAqB;IAC5C,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;IAEtC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO;CAG3D"}

package/dest/public/avm/opcodes/comparators.js

@@ -0,0 +1,43 @@
+import { Uint1 } from '../avm_memory_types.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+class ComparatorInstruction extends ThreeOperandInstruction {
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.aOffset,
+            this.bOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
+        memory.checkTagsAreSame(aOffset, bOffset);
+        const a = memory.get(aOffset);
+        const b = memory.get(bOffset);
+        const dest = new Uint1(this.compare(a, b) ? 1 : 0);
+        memory.set(dstOffset, dest);
+    }
+}
+export class Eq extends ComparatorInstruction {
+    static type = 'EQ';
+    static opcode = Opcode.EQ_8;
+    compare(a, b) {
+        return a.equals(b);
+    }
+}
+export class Lt extends ComparatorInstruction {
+    static type = 'LT';
+    static opcode = Opcode.LT_8;
+    compare(a, b) {
+        return a.lt(b);
+    }
+}
+export class Lte extends ComparatorInstruction {
+    static type = 'LTE';
+    static opcode = Opcode.LTE_8;
+    compare(a, b) {
+        return a.lt(b) || a.equals(b);
+    }
+}

package/dest/public/avm/opcodes/contract.d.ts

@@ -0,0 +1,21 @@
+import type { AvmContext } from '../avm_context.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+export declare enum ContractInstanceMember {
+    DEPLOYER = 0,
+    CLASS_ID = 1,
+    INIT_HASH = 2
+}
+export declare class GetContractInstance extends Instruction {
+    private indirect;
+    private addressOffset;
+    private dstOffset;
+    private existsOffset;
+    private memberEnum;
+    static readonly type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, addressOffset: number, dstOffset: number, existsOffset: number, memberEnum: number);
+    execute(context: AvmContext): Promise<void>;
+}
+//# sourceMappingURL=contract.d.ts.map

package/dest/public/avm/opcodes/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,oBAAY,sBAAsB;IAChC,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,SAAS,IAAA;CACV;AAED,qBAAa,mBAAoB,SAAQ,WAAW;IAchD,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,UAAU;IAjBpB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAyB;IACrD,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAA8B;IAE5D,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAOvC;gBAGQ,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM;IAKtB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAmClD"}

package/dest/public/avm/opcodes/contract.js

@@ -0,0 +1,66 @@
+import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+export var ContractInstanceMember = /*#__PURE__*/ function(ContractInstanceMember) {
+    ContractInstanceMember[ContractInstanceMember["DEPLOYER"] = 0] = "DEPLOYER";
+    ContractInstanceMember[ContractInstanceMember["CLASS_ID"] = 1] = "CLASS_ID";
+    ContractInstanceMember[ContractInstanceMember["INIT_HASH"] = 2] = "INIT_HASH";
+    return ContractInstanceMember;
+}({});
+export class GetContractInstance extends Instruction {
+    indirect;
+    addressOffset;
+    dstOffset;
+    existsOffset;
+    memberEnum;
+    static type = 'GETCONTRACTINSTANCE';
+    static opcode = Opcode.GETCONTRACTINSTANCE;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT8
+    ];
+    constructor(indirect, addressOffset, dstOffset, existsOffset, memberEnum){
+        super(), this.indirect = indirect, this.addressOffset = addressOffset, this.dstOffset = dstOffset, this.existsOffset = existsOffset, this.memberEnum = memberEnum;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        if (!(this.memberEnum in ContractInstanceMember)) {
+            throw new InstructionExecutionError(`Invalid GETCONSTRACTINSTANCE member enum ${this.memberEnum}`);
+        }
+        const operands = [
+            this.addressOffset,
+            this.dstOffset,
+            this.existsOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [addressOffset, dstOffset, existsOffset] = addressing.resolve(operands, memory);
+        memory.checkTag(TypeTag.FIELD, addressOffset);
+        const address = memory.get(addressOffset).toAztecAddress();
+        const instance = await context.persistableState.getContractInstance(address);
+        const exists = instance !== undefined;
+        let memberValue = new Field(0);
+        if (exists) {
+            switch(this.memberEnum){
+                case 0:
+                    memberValue = new Field(instance.deployer.toField());
+                    break;
+                case 1:
+                    memberValue = new Field(instance.currentContractClassId.toField());
+                    break;
+                case 2:
+                    memberValue = new Field(instance.initializationHash);
+                    break;
+            }
+        }
+        memory.set(existsOffset, new Uint1(exists ? 1 : 0));
+        memory.set(dstOffset, memberValue);
+    }
+}

package/dest/public/avm/opcodes/control_flow.d.ts

@@ -0,0 +1,41 @@
+import type { AvmContext } from '../avm_context.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+export declare class Jump extends Instruction {
+    private jumpOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(jumpOffset: number);
+    execute(context: AvmContext): Promise<void>;
+    handlesPC(): boolean;
+}
+export declare class JumpI extends Instruction {
+    private indirect;
+    private condOffset;
+    private loc;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, condOffset: number, loc: number);
+    execute(context: AvmContext): Promise<void>;
+    handlesPC(): boolean;
+}
+export declare class InternalCall extends Instruction {
+    private loc;
+    static readonly type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(loc: number);
+    execute(context: AvmContext): Promise<void>;
+    handlesPC(): boolean;
+}
+export declare class InternalReturn extends Instruction {
+    static readonly type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor();
+    execute(context: AvmContext): Promise<void>;
+    handlesPC(): boolean;
+}
+//# sourceMappingURL=control_flow.d.ts.map

package/dest/public/avm/opcodes/control_flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control_flow.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/control_flow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,qBAAa,IAAK,SAAQ,WAAW;IAMvB,OAAO,CAAC,UAAU;IAL9B,MAAM,CAAC,IAAI,EAAE,MAAM,CAAU;IAC7B,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAkB;IAEhD,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAA2C;gBAEhE,UAAU,EAAE,MAAM;IAIzB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAMxC,SAAS,IAAI,OAAO;CAGrC;AAED,qBAAa,KAAM,SAAQ,WAAW;IAYxB,OAAO,CAAC,QAAQ;IAAU,OAAO,CAAC,UAAU;IAAU,OAAO,CAAC,GAAG;IAX7E,MAAM,CAAC,IAAI,EAAE,MAAM,CAAW;IAC9B,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAmB;IAGjD,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAKvC;gBAEkB,QAAQ,EAAE,MAAM,EAAU,UAAU,EAAE,MAAM,EAAU,GAAG,EAAE,MAAM;IAIxE,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxC,SAAS,IAAI,OAAO;CAGrC;AAED,qBAAa,YAAa,SAAQ,WAAW;IAM/B,OAAO,CAAC,GAAG;IALvB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAkB;IAC9C,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAuB;IAErD,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAA2C;gBAEhE,GAAG,EAAE,MAAM;IAIlB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAUxC,SAAS,IAAI,OAAO;CAGrC;AAED,qBAAa,cAAe,SAAQ,WAAW;IAC7C,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAoB;IAChD,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAyB;IAEvD,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAAuB;;IAMnD,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAUxC,SAAS,IAAI,OAAO;CAGrC"}

package/dest/public/avm/opcodes/control_flow.js

@@ -0,0 +1,105 @@
+import { InstructionExecutionError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+export class Jump extends Instruction {
+    jumpOffset;
+    static type = 'JUMP';
+    static opcode = Opcode.JUMP_32;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT32
+    ];
+    constructor(jumpOffset){
+        super(), this.jumpOffset = jumpOffset;
+    }
+    async execute(context) {
+        context.machineState.consumeGas(this.gasCost());
+        context.machineState.pc = this.jumpOffset;
+    }
+    handlesPC() {
+        return true;
+    }
+}
+export class JumpI extends Instruction {
+    indirect;
+    condOffset;
+    loc;
+    static type = 'JUMPI';
+    static opcode = Opcode.JUMPI_32;
+    // Instruction wire format with opcode.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT32
+    ];
+    constructor(indirect, condOffset, loc){
+        super(), this.indirect = indirect, this.condOffset = condOffset, this.loc = loc;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.condOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [condOffset] = addressing.resolve(operands, memory);
+        const condition = memory.getAs(condOffset);
+        if (condition.toBigInt() == 0n) {
+            context.machineState.pc = context.machineState.nextPc;
+        } else {
+            context.machineState.pc = this.loc;
+        }
+    }
+    handlesPC() {
+        return true;
+    }
+}
+export class InternalCall extends Instruction {
+    loc;
+    static type = 'INTERNALCALL';
+    static opcode = Opcode.INTERNALCALL;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT32
+    ];
+    constructor(loc){
+        super(), this.loc = loc;
+    }
+    async execute(context) {
+        context.machineState.consumeGas(this.gasCost());
+        context.machineState.internalCallStack.push({
+            callPc: context.machineState.pc,
+            returnPc: context.machineState.nextPc
+        });
+        context.machineState.pc = this.loc;
+    }
+    handlesPC() {
+        return true;
+    }
+}
+export class InternalReturn extends Instruction {
+    static type = 'INTERNALRETURN';
+    static opcode = Opcode.INTERNALRETURN;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8
+    ];
+    constructor(){
+        super();
+    }
+    async execute(context) {
+        context.machineState.consumeGas(this.gasCost());
+        const stackEntry = context.machineState.internalCallStack.pop();
+        if (stackEntry === undefined) {
+            throw new InstructionExecutionError('Internal call stack empty!');
+        }
+        context.machineState.pc = stackEntry.returnPc;
+    }
+    handlesPC() {
+        return true;
+    }
+}

package/dest/public/avm/opcodes/conversion.d.ts

@@ -0,0 +1,17 @@
+import type { AvmContext } from '../avm_context.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+export declare class ToRadixBE extends Instruction {
+    private indirect;
+    private srcOffset;
+    private radixOffset;
+    private numLimbsOffset;
+    private outputBitsOffset;
+    private dstOffset;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, srcOffset: number, radixOffset: number, numLimbsOffset: number, outputBitsOffset: number, dstOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+//# sourceMappingURL=conversion.d.ts.map

package/dest/public/avm/opcodes/conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversion.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/conversion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,qBAAa,SAAU,SAAQ,WAAW;IAgBtC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,SAAS;IApBnB,MAAM,CAAC,IAAI,EAAE,MAAM,CAAe;IAClC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAoB;IAGlD,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAQvC;gBAGQ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,gBAAgB,EAAE,MAAM,EACxB,SAAS,EAAE,MAAM;IAKd,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CA8CzD"}