dequanto 0.0.1 → 0.0.7

package/dist/src/evm/opcodes/mstore.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MSTORE = void 0;
+const _is_1 = require("@dequanto/utils/$is");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+class MSTORE {
+    constructor(location, data) {
+        this.name = 'MSTORE';
+        this.wrapped = true;
+        this.location = location;
+        this.data = data;
+    }
+    toString() {
+        return 'memory[' + (0, stringify_1.default)(this.location) + '] = ' + (0, stringify_1.default)(this.data) + ';';
+    }
+}
+exports.MSTORE = MSTORE;
+exports.default = (opcode, state) => {
+    const storeLocation = state.stack.pop();
+    const storeData = state.stack.pop();
+    if (_is_1.$is.BigInt(storeLocation)) {
+        state.memory[Number(storeLocation)] = storeData;
+    }
+    else {
+        state.instructions.push(new MSTORE(storeLocation, storeData));
+    }
+};

package/dist/src/evm/opcodes/mul.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MUL = void 0;
+const _is_1 = require("@dequanto/utils/$is");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+class MUL {
+    constructor(left, right) {
+        this.name = 'MUL';
+        this.wrapped = true;
+        this.left = left;
+        this.right = right;
+    }
+    toString() {
+        return (0, stringify_1.default)(this.left) + ' * ' + (0, stringify_1.default)(this.right);
+    }
+}
+exports.MUL = MUL;
+exports.default = (opcode, state) => {
+    const left = state.stack.pop();
+    const right = state.stack.pop();
+    if (_is_1.$is.BigInt(left) && _is_1.$is.BigInt(right)) {
+        state.stack.push(left * right);
+    }
+    else if ((_is_1.$is.BigInt(left) && left === 0n) ||
+        (_is_1.$is.BigInt(right) && right === 0n)) {
+        state.stack.push(0n);
+    }
+    else {
+        state.stack.push(new MUL(left, right));
+    }
+};

package/dist/src/evm/opcodes/mulmod.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mul_1 = require("./mul");
+const mod_1 = require("./mod");
+const _is_1 = require("@dequanto/utils/$is");
+exports.default = (opcode, state) => {
+    const left = state.stack.pop();
+    const right = state.stack.pop();
+    const mod = state.stack.pop();
+    if (_is_1.$is.BigInt(left) && _is_1.$is.BigInt(right) && _is_1.$is.BigInt(mod)) {
+        state.stack.push(left * right % mod);
+    }
+    else if (_is_1.$is.BigInt(left) && _is_1.$is.BigInt(right)) {
+        state.stack.push(new mod_1.MOD(left * right, mod));
+    }
+    else {
+        state.stack.push(new mod_1.MOD(new mul_1.MUL(left, right), mod));
+    }
+};

package/dist/src/evm/opcodes/not.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOT = void 0;
+const _is_1 = require("@dequanto/utils/$is");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+class NOT {
+    constructor(item) {
+        this.name = 'AND';
+        this.wrapped = true;
+        this.item = item;
+    }
+    toString() {
+        return '~' + (0, stringify_1.default)(this.item);
+    }
+}
+exports.NOT = NOT;
+exports.default = (opcode, state) => {
+    const item = state.stack.pop();
+    if (_is_1.$is.BigInt(item)) {
+        state.stack.push(!item);
+    }
+    else {
+        state.stack.push(new NOT(item));
+    }
+};

package/dist/src/evm/opcodes/number.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NUMBER = void 0;
+class NUMBER {
+    constructor() {
+        this.name = 'NUMBER';
+        this.wrapped = false;
+    }
+    toString() {
+        return 'block.number';
+    }
+}
+exports.NUMBER = NUMBER;
+exports.default = (opcode, state) => {
+    state.stack.push(new NUMBER());
+};

package/dist/src/evm/opcodes/or.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OR = void 0;
+const _is_1 = require("@dequanto/utils/$is");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+class OR {
+    constructor(left, right) {
+        this.name = 'OR';
+        this.wrapped = true;
+        this.left = left;
+        this.right = right;
+    }
+    toString() {
+        return (0, stringify_1.default)(this.left) + ' || ' + (0, stringify_1.default)(this.right);
+    }
+}
+exports.OR = OR;
+exports.default = (opcode, state) => {
+    const left = state.stack.pop();
+    const right = state.stack.pop();
+    if (_is_1.$is.BigInt(left) && _is_1.$is.BigInt(right)) {
+        state.stack.push(left || right);
+    }
+    else {
+        state.stack.push(new OR(left, right));
+    }
+};

package/dist/src/evm/opcodes/origin.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORIGIN = void 0;
+class ORIGIN {
+    constructor() {
+        this.name = 'ORIGIN';
+        this.wrapped = false;
+    }
+    toString() {
+        return 'tx.origin';
+    }
+}
+exports.ORIGIN = ORIGIN;
+exports.default = (opcode, state) => {
+    state.stack.push(new ORIGIN());
+};

package/dist/src/evm/opcodes/pc.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (opcode, state) => {
+    state.stack.push(BigInt(opcode.pc));
+};

package/dist/src/evm/opcodes/pop.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (opcode, state) => {
+    state.stack.pop();
+};

package/dist/src/evm/opcodes/push.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (opcode, state) => {
+    const pushDataLength = parseInt(opcode.name.replace('PUSH', ''), 10);
+    state.stack.push(BigInt('0x' + opcode.pushData.toString('hex')));
+};

package/dist/src/evm/opcodes/return.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETURN = void 0;
+const mload_1 = require("./mload");
+const hex_1 = require("../utils/hex");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+const _is_1 = require("@dequanto/utils/$is");
+class RETURN {
+    constructor(items, memoryStart, memoryLength) {
+        this.name = 'RETURN';
+        this.wrapped = true;
+        if (memoryStart && memoryLength) {
+            this.memoryStart = memoryStart;
+            this.memoryLength = memoryLength;
+        }
+        else {
+            this.items = items;
+        }
+    }
+    toString() {
+        if (this.memoryStart && this.memoryLength) {
+            return ('return memory[' +
+                (0, stringify_1.default)(this.memoryStart) +
+                ':(' +
+                (0, stringify_1.default)(this.memoryStart) +
+                '+' +
+                (0, stringify_1.default)(this.memoryLength) +
+                ')];');
+        }
+        else if (this.items.length === 0) {
+            return 'return;';
+        }
+        else if (this.items.length === 1 &&
+            (_is_1.$is.BigInt(this.items[0]) || this.items[0].static)) {
+            return 'return ' + this.items[0] + ';';
+        }
+        else if (this.items.length === 3 &&
+            this.items.every((item) => _is_1.$is.BigInt(item)) &&
+            this.items[0].equals(32)) {
+            return 'return "' + (0, hex_1.hex2a)(this.items[2].toString(16)) + '";';
+        }
+        else {
+            return 'return(' + this.items.map((item) => (0, stringify_1.default)(item)).join(', ') + ');';
+        }
+    }
+}
+exports.RETURN = RETURN;
+exports.default = (opcode, state) => {
+    const memoryStart = state.stack.pop();
+    const memoryLength = state.stack.pop();
+    state.halted = true;
+    if (_is_1.$is.BigInt(memoryStart) && _is_1.$is.BigInt(memoryLength)) {
+        const items = [];
+        for (let i = Number(memoryStart); i < Number(memoryStart) + Number(memoryLength); i += 32) {
+            if (i in state.memory) {
+                items.push(state.memory[i]);
+            }
+            else {
+                items.push(new mload_1.MLOAD(i));
+            }
+        }
+        state.instructions.push(new RETURN(items));
+    }
+    else {
+        state.instructions.push(new RETURN([], memoryStart, memoryLength));
+    }
+};

package/dist/src/evm/opcodes/returndatacopy.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETURNDATACOPY = void 0;
+const stringify_1 = __importDefault(require("../utils/stringify"));
+class RETURNDATACOPY {
+    constructor(returnDataPosition, returnDataSize) {
+        this.name = 'RETURNDATACOPY';
+        this.wrapped = true;
+        this.returnDataPosition = returnDataPosition;
+        this.returnDataSize = returnDataSize;
+    }
+    toString() {
+        return ('output[' +
+            (0, stringify_1.default)(this.returnDataPosition) +
+            ':(' +
+            (0, stringify_1.default)(this.returnDataPosition) +
+            '+' +
+            (0, stringify_1.default)(this.returnDataSize) +
+            ')]');
+    }
+}
+exports.RETURNDATACOPY = RETURNDATACOPY;
+exports.default = (opcode, state) => {
+    const memoryPosition = state.stack.pop();
+    const returnDataPosition = state.stack.pop();
+    const returnDataSize = state.stack.pop();
+    state.memory[memoryPosition] = new RETURNDATACOPY(returnDataPosition, returnDataSize);
+};

package/dist/src/evm/opcodes/returndatasize.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETURNDATASIZE = void 0;
+class RETURNDATASIZE {
+    constructor() {
+        this.name = 'RETURNDATASIZE';
+        this.wrapped = false;
+    }
+    toString() {
+        return 'output.length';
+    }
+}
+exports.RETURNDATASIZE = RETURNDATASIZE;
+exports.default = (opcode, state) => {
+    state.stack.push(new RETURNDATASIZE());
+};

package/dist/src/evm/opcodes/revert.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REVERT = void 0;
+const mload_1 = require("./mload");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+const _is_1 = require("@dequanto/utils/$is");
+class REVERT {
+    constructor(items, memoryStart, memoryLength) {
+        this.name = 'REVERT';
+        this.wrapped = true;
+        if (memoryStart && memoryLength) {
+            this.memoryStart = memoryStart;
+            this.memoryLength = memoryLength;
+        }
+        else {
+            this.items = items;
+        }
+    }
+    toString() {
+        if (this.items) {
+            return 'revert(' + this.items.map((item) => (0, stringify_1.default)(item)).join(', ') + ');';
+        }
+        else {
+            return ('revert(memory[' +
+                (0, stringify_1.default)(this.memoryStart) +
+                ':(' +
+                (0, stringify_1.default)(this.memoryStart) +
+                '+' +
+                (0, stringify_1.default)(this.memoryLength) +
+                ')]);');
+        }
+    }
+}
+exports.REVERT = REVERT;
+exports.default = (opcode, state) => {
+    const memoryStart = state.stack.pop();
+    const memoryLength = state.stack.pop();
+    state.halted = true;
+    if (_is_1.$is.BigInt(memoryStart) && _is_1.$is.BigInt(memoryLength)) {
+        const items = [];
+        for (let i = Number(memoryStart); i < Number(memoryStart + memoryLength); i += 32) {
+            if (i in state.memory) {
+                items.push(state.memory[i]);
+            }
+            else {
+                items.push(new mload_1.MLOAD(i));
+            }
+        }
+        state.instructions.push(new REVERT(items));
+    }
+    else {
+        state.instructions.push(new REVERT([], memoryStart, memoryLength));
+    }
+};

package/dist/src/evm/opcodes/sar.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAR = void 0;
+const _is_1 = require("@dequanto/utils/$is");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+class SAR {
+    constructor(left, right) {
+        this.name = 'SAR';
+        this.wrapped = true;
+        this.left = left;
+        this.right = right;
+    }
+    toString() {
+        return (0, stringify_1.default)(this.left) + ' >> ' + (0, stringify_1.default)(this.right);
+    }
+}
+exports.SAR = SAR;
+exports.default = (opcode, state) => {
+    const left = state.stack.pop();
+    const right = state.stack.pop();
+    if (_is_1.$is.BigInt(left) && _is_1.$is.BigInt(right)) {
+        state.stack.push(left >> right);
+    }
+    else {
+        state.stack.push(new SAR(left, right));
+    }
+};

package/dist/src/evm/opcodes/selfdestruct.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SELFDESTRUCT = void 0;
+const stringify_1 = __importDefault(require("../utils/stringify"));
+class SELFDESTRUCT {
+    constructor(address) {
+        this.name = 'SELFDESTRUCT';
+        this.wrapped = true;
+        this.address = address;
+    }
+    toString() {
+        return 'selfdestruct(' + (0, stringify_1.default)(this.address) + ');';
+    }
+}
+exports.SELFDESTRUCT = SELFDESTRUCT;
+exports.default = (opcode, state) => {
+    const address = state.stack.pop();
+    state.halted = true;
+    state.instructions.push(new SELFDESTRUCT(address));
+};

package/dist/src/evm/opcodes/sha3.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHA3 = void 0;
+const mload_1 = require("./mload");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+const _is_1 = require("@dequanto/utils/$is");
+class SHA3 {
+    constructor(items, memoryStart, memoryLength) {
+        this.name = 'SHA3';
+        this.wrapped = false;
+        if (memoryStart && memoryLength) {
+            this.memoryStart = memoryStart;
+            this.memoryLength = memoryLength;
+        }
+        else {
+            this.items = items;
+        }
+    }
+    toString() {
+        if (this.items) {
+            return 'keccak256(' + this.items.map((item) => (0, stringify_1.default)(item)).join(', ') + ')';
+        }
+        else {
+            return ('keccak256(memory[' +
+                (0, stringify_1.default)(this.memoryStart) +
+                ':(' +
+                (0, stringify_1.default)(this.memoryStart) +
+                '+' +
+                (0, stringify_1.default)(this.memoryLength) +
+                ')])');
+        }
+    }
+}
+exports.SHA3 = SHA3;
+exports.default = (opcode, state) => {
+    const memoryStart = state.stack.pop();
+    const memoryLength = state.stack.pop();
+    if (_is_1.$is.BigInt(memoryStart) && _is_1.$is.BigInt(memoryLength)) {
+        const items = [];
+        for (let i = Number(memoryStart); i < Number(memoryStart + memoryLength); i += 32) {
+            if (i in state.memory) {
+                items.push(state.memory[i]);
+            }
+            else {
+                items.push(new mload_1.MLOAD(i));
+            }
+        }
+        state.stack.push(new SHA3(items));
+    }
+    else {
+        state.stack.push(new SHA3([], memoryStart, memoryLength));
+    }
+};

package/dist/src/evm/opcodes/shl.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHL = void 0;
+const _is_1 = require("@dequanto/utils/$is");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+class SHL {
+    constructor(left, right) {
+        this.name = 'SHL';
+        this.wrapped = true;
+        this.left = left;
+        this.right = right;
+    }
+    toString() {
+        return (0, stringify_1.default)(this.left) + ' << ' + (0, stringify_1.default)(this.right);
+    }
+}
+exports.SHL = SHL;
+exports.default = (opcode, state) => {
+    const shift = state.stack.pop();
+    const value = state.stack.pop();
+    if (_is_1.$is.BigInt(shift) && _is_1.$is.BigInt(value)) {
+        if (shift > 255n) {
+            state.stack.push(0n);
+            return;
+        }
+        let result = value << shift;
+        let trimmed = BigInt('0x' + result.toString(16).slice(-64));
+        state.stack.push(trimmed);
+        return;
+    }
+    state.stack.push(new SHL(shift, value));
+};

package/dist/src/evm/opcodes/shr.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHR = void 0;
+const stringify_1 = __importDefault(require("../utils/stringify"));
+const _is_1 = require("@dequanto/utils/$is");
+class SHR {
+    constructor(left, right) {
+        this.name = 'SHR';
+        this.wrapped = true;
+        this.left = left;
+        this.right = right;
+    }
+    toString() {
+        return (0, stringify_1.default)(this.left) + ' >>> ' + (0, stringify_1.default)(this.right);
+    }
+}
+exports.SHR = SHR;
+exports.default = (opcode, state) => {
+    const left = state.stack.pop();
+    const right = state.stack.pop();
+    if (_is_1.$is.BigInt(left) && _is_1.$is.BigInt(right)) {
+        state.stack.push(left >> right);
+    }
+    else {
+        state.stack.push(new SHR(left, right));
+    }
+};

package/dist/src/evm/opcodes/signextend.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shl_1 = require("./shl");
+const sar_1 = require("./sar");
+const sub_1 = require("./sub");
+const _is_1 = require("@dequanto/utils/$is");
+exports.default = (opcode, state) => {
+    const left = state.stack.pop();
+    const right = state.stack.pop();
+    if (_is_1.$is.BigInt(left) && _is_1.$is.BigInt(right)) {
+        state.stack.push((right << (32n - left)) >> (32n - left));
+    }
+    else if (_is_1.$is.BigInt(left)) {
+        state.stack.push(new sar_1.SAR(new shl_1.SHL(right, 32n - left), 32n - left));
+    }
+    else {
+        state.stack.push(new sar_1.SAR(new shl_1.SHL(right, new sub_1.SUB(32n, left)), new sub_1.SUB(32n, left)));
+    }
+};