dequanto 0.0.1 → 0.0.7

package/dist/src/evm/EVM.js

@@ -0,0 +1,214 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVM = void 0;
+const alot_1 = __importDefault(require("alot"));
+const opcodes_1 = require("./opcodes");
+const JsonObjectStore_1 = require("@dequanto/json/JsonObjectStore");
+const _path_1 = require("@dequanto/utils/$path");
+const _abiParser_1 = require("@dequanto/utils/$abiParser");
+const Stack_1 = __importDefault(require("./Stack"));
+const OpcodesWalker_1 = require("./OpcodesWalker");
+const _logger_1 = require("@dequanto/utils/$logger");
+/**
+ * Functions to SKIP
+ * 08c379a0 - Error(string)
+ * 4e487b71 - Panic(uint256)
+ * ffffffff -
+ */
+class Stores {
+    constructor() {
+        this.functions = new JsonObjectStore_1.JsonObjectStore({
+            path: _path_1.$path.resolve(`/data/evm/functionHashes.json`)
+        });
+        this.events = new JsonObjectStore_1.JsonObjectStore({
+            path: _path_1.$path.resolve(`/data/evm/eventHashes.json`)
+        });
+    }
+    async readAll() {
+        let [functions, events] = await Promise.all([
+            this.functions.get(),
+            this.events.get(),
+        ]);
+        this.functionHashes = functions;
+        this.eventHashes = events;
+    }
+}
+class EVM {
+    constructor(code) {
+        this.pc = 0;
+        this.stack = new Stack_1.default();
+        this.memory = {};
+        this.instructions = [];
+        this.storage = {};
+        this.jumps = {};
+        this.mappings = {};
+        this.layer = 0;
+        this.halted = false;
+        this.functions = {};
+        this.variables = {};
+        this.events = {};
+        this.gasUsed = 0;
+        this.opcodes = [];
+        this.store = new Stores();
+        if (code instanceof Buffer) {
+            this.code = code;
+        }
+        else {
+            // remove the constructor code, leave the runtime bytecode only;
+            let initCode = code.indexOf('6080604052', 4);
+            if (initCode > -1) {
+                code = code.substring(initCode);
+            }
+            this.code = Buffer.from(code.replace('0x', ''), 'hex');
+        }
+    }
+    getOpcodes() {
+        if (this.opcodes.length === 0) {
+            for (let index = 0; index < this.code.length; index++) {
+                const currentOp = (0, opcodes_1.findOpcode)(this.code[index], true);
+                currentOp.pc = index;
+                this.opcodes.push(currentOp);
+                if (currentOp.name.startsWith('PUSH')) {
+                    const pushDataLength = this.code[index] - 0x5f;
+                    const pushData = this.code.slice(index + 1, index + pushDataLength + 1);
+                    currentOp.pushData = pushData;
+                    index += pushDataLength;
+                }
+            }
+        }
+        return this.opcodes;
+    }
+    async getAbi() {
+        await this.prepair();
+        let [functions, events] = await Promise.all([
+            this.getFunctions(),
+            this.getEvents(),
+        ]);
+        let fnsAbi = await (0, alot_1.default)(functions).mapAsync(async (entry) => {
+            let str = entry.name ?? `_${entry.signature}()`;
+            let abi = _abiParser_1.$abiParser.parseMethod(str);
+            try {
+                let { opcodes } = this.getMethodOpcodes({ sig: entry.signature });
+                let isReadOnly = $opcodes.isReadOnly(opcodes);
+                if (isReadOnly) {
+                    abi.stateMutability = 'view';
+                }
+            }
+            catch (error) {
+                _logger_1.$logger.error(`Getting method ${str} opcodes failed: ${error.message}`);
+            }
+            return abi;
+        }).toArrayAsync();
+        let eventsAbi = events.map(entry => {
+            if (entry.name == null) {
+                return null;
+            }
+            let str = `event ${entry.name}`;
+            return _abiParser_1.$abiParser.parseMethod(str);
+        }).filter(Boolean);
+        return [
+            ...fnsAbi,
+            ...eventsAbi,
+        ];
+    }
+    async getFunctions() {
+        let SKIP = [
+            null,
+            '08c379a0',
+            '4e487b71',
+            'ffffffff'
+        ];
+        let hashes = this
+            .getOpcodes()
+            .filter(opcode => opcode.name === 'PUSH4')
+            .map((opcode, i) => {
+            return opcode.pushData?.toString('hex') ?? null;
+        })
+            .filter(x => SKIP.includes(x) === false);
+        let fns = await this.resolveFunctions(hashes);
+        return fns;
+    }
+    async resolveFunctions(hashes) {
+        let fns = await this.store.functions.get();
+        return (0, alot_1.default)(hashes)
+            .distinct()
+            .map(hash => {
+            return {
+                signature: `0x` + hash,
+                name: fns[hash] ?? null
+            };
+        })
+            .toArray();
+    }
+    async getEvents() {
+        let hashes = this.getOpcodes()
+            .filter(opcode => opcode.name === 'PUSH32')
+            .map(opcode => opcode.pushData?.toString('hex') ?? null)
+            .filter(x => x != null);
+        let events = await this.resolveEvents(hashes);
+        return events;
+    }
+    clone() {
+        const clone = new EVM(this.code);
+        clone.pc = this.pc;
+        clone.opcodes = this.opcodes;
+        clone.stack = this.stack.clone();
+        clone.memory = { ...this.memory };
+        clone.storage = this.storage;
+        clone.jumps = { ...this.jumps };
+        clone.mappings = this.mappings;
+        clone.layer = this.layer + 1;
+        clone.functions = this.functions;
+        clone.variables = this.variables;
+        clone.events = this.events;
+        clone.gasUsed = this.gasUsed;
+        clone.store = this.store;
+        return clone;
+    }
+    async prepair() {
+        await this.store.readAll();
+        return this;
+    }
+    getMethodOpcodes(mix) {
+        this.stack.reset();
+        let opcodes = this.getOpcodes();
+        let walker = new OpcodesWalker_1.OpcodesWalker(this, opcodes);
+        return walker.getMethodOpcodes(mix);
+    }
+    async resolveEvents(hashes) {
+        let events = await this.store.events.get();
+        return (0, alot_1.default)(hashes)
+            .distinct()
+            .map(hash => {
+            return {
+                signature: `0x` + hash,
+                name: events[hash] ?? null
+            };
+        })
+            .toArray();
+    }
+}
+exports.EVM = EVM;
+var $opcodes;
+(function ($opcodes) {
+    function isReadOnly(opcodes) {
+        let writes = [
+            'SSTORE',
+            'LOG'
+        ];
+        let hasWrite = opcodes.some(opcode => writes.includes(opcode.name));
+        if (hasWrite) {
+            return false;
+        }
+        // Read methods usually have RETURN code
+        let hasStop = opcodes.some(opcode => 'STOP' === opcode.name);
+        if (hasStop) {
+            return false;
+        }
+        return true;
+    }
+    $opcodes.isReadOnly = isReadOnly;
+})($opcodes || ($opcodes = {}));

package/dist/src/evm/OpcodesWalker.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsOpcode = exports.OpcodesWalker = void 0;
+const _abiUtils_1 = require("@dequanto/utils/$abiUtils");
+const Stack_1 = __importDefault(require("./Stack"));
+const opcodes_1 = __importDefault(require("./utils/opcodes"));
+class OpcodesWalker {
+    constructor(evm, opcodes) {
+        this.evm = evm;
+        this.opcodes = opcodes;
+        this.stack = new Stack_1.default();
+    }
+    getMethodOpcodes(mix) {
+        let sig = typeof mix === 'string'
+            ? _abiUtils_1.$abiUtils.getMethodSignature(mix)
+            : mix.sig;
+        let method = this.opcodes.find(x => x.name === 'PUSH4' && x.pushData?.toString('hex') === sig.substring(2));
+        if (method == null) {
+            throw new Error(`ABI ${JSON.stringify(mix)} not found in bytecode`);
+        }
+        this.evm.pc = method.pc;
+        this.current = method;
+        while (this.next() != null) {
+            if (IsOpcode.ofType(this.current, 'JUMP') === false) {
+                opcodes_1.default[this.current.name](this.current, this.evm);
+                continue;
+            }
+            let dest = this.evm.stack.pop();
+            let destOpcode = this.next(dest);
+            if (IsOpcode.ofType(destOpcode, 'JUMPDEST') === false) {
+                throw new Error(`Jump to ${dest} should be a destination opcode, got ${destOpcode?.name}`);
+            }
+            break;
+        }
+        let { opcodes, exit } = this.goToExit();
+        return { opcodes, exit };
+    }
+    goToExit(prev) {
+        if (prev != null) {
+            this.current = prev;
+            this.evm.pc = prev.pc;
+        }
+        let visited = [];
+        let seen = 0;
+        while (this.next() != null) {
+            if (visited.includes(this.current)) {
+                seen++;
+                const MAX_LOOP_DEPTH = 100;
+                if (seen > MAX_LOOP_DEPTH) {
+                    return {
+                        opcodes: visited,
+                        exit: 'LOOP'
+                    };
+                }
+            }
+            else {
+                seen = 0;
+                visited.push(this.current);
+            }
+            let name = this.current.name;
+            if (name === 'RETURN' || name === 'STOP') {
+                return {
+                    opcodes: visited,
+                    exit: name
+                };
+            }
+            if (name === 'REVERT' || name === 'INVALID') {
+                return {
+                    opcodes: visited,
+                    exit: name,
+                };
+            }
+            // process any non-jump opcodes
+            if (IsOpcode.ofType(this.current, 'JUMP') === false) {
+                opcodes_1.default[this.current.name](this.current, this.evm);
+                continue;
+            }
+            let destination = this.evm.stack.pop();
+            if (this.current.name === 'JUMPI') {
+                // Is Conditional
+                this.evm.stack.pop();
+                // Visit falsy leaf (as if the jump not occured)
+                let evm = this.evm.clone();
+                let walker = new OpcodesWalker(evm, this.opcodes);
+                let { opcodes } = walker.goToExit(this.current);
+                visited.push(...opcodes);
+            }
+            let destOpcode = this.next(destination);
+            if (IsOpcode.ofType(destOpcode, 'JUMPDEST') === false) {
+                throw new Error(`Jump to ${destination} should be a destination opcode, got ${destOpcode?.name}`);
+            }
+        }
+        return {
+            opcodes: visited,
+            exit: 'END'
+        };
+    }
+    next(dest) {
+        if (dest != null) {
+            if (typeof dest === 'bigint') {
+                dest = Number(dest);
+            }
+            if (typeof dest === 'number') {
+                let opcode = this.opcodes.find(x => x.pc === dest);
+                if (opcode == null) {
+                    console.log(this.opcodes.map(x => `${x.pc.toString(16)} ${x.name}`).join('\n'));
+                    throw new Error(`No OPCODE found at ${dest.toString(16)}`);
+                }
+                this.current = opcode;
+                this.evm.pc = this.current.pc;
+                return this.current;
+            }
+        }
+        let i = this.opcodes.indexOf(this.current);
+        this.current = this.opcodes[i + 1];
+        this.evm.pc = this.current.pc;
+        return this.current;
+    }
+}
+exports.OpcodesWalker = OpcodesWalker;
+var IsOpcode;
+(function (IsOpcode) {
+    function ofType(opcode, name) {
+        if (opcode == null) {
+            return false;
+        }
+        if (typeof name === 'string') {
+            let rgx = new RegExp(name, 'i');
+            return rgx.test(opcode.name);
+        }
+        return false;
+    }
+    IsOpcode.ofType = ofType;
+})(IsOpcode = exports.IsOpcode || (exports.IsOpcode = {}));

package/dist/src/evm/Stack.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Stack {
+    constructor() {
+        this.elements = [];
+    }
+    push(item) {
+        if (this.elements.length >= 1024) {
+            throw new Error('Stack too deep');
+        }
+        else {
+            this.elements.unshift(item);
+        }
+    }
+    pop() {
+        if (this.elements.length === 0) {
+            // throw new Error('POP with empty stack');
+        }
+        else {
+            return this.elements.shift();
+        }
+    }
+    duplicate(position) {
+        if (position < 0 || position > 15) {
+            throw new Error('Unsupported position for duplication operation');
+        }
+        else if (!(position in this.elements)) {
+            throw new Error("Invalid duplication operation, provided position wasn't found in stack");
+        }
+        else {
+            this.push(this.elements[position]);
+        }
+    }
+    swap(secondPosition) {
+        if (secondPosition < 1 || secondPosition > 16) {
+            throw new Error('Unsupported position for swap operation');
+        }
+        else if (!(secondPosition in this.elements)) {
+            throw new Error("Invalid swap operation, provided position wasn't found in stack");
+        }
+        else {
+            const firstValue = this.elements[0];
+            const secondValue = this.elements[secondPosition];
+            this.elements[0] = secondValue;
+            this.elements[secondPosition] = firstValue;
+        }
+    }
+    clone() {
+        const stack = new Stack();
+        stack.elements = [...this.elements];
+        return stack;
+    }
+    reset() {
+        this.elements = [];
+    }
+}
+exports.default = Stack;

package/dist/src/evm/interfaces/IJumps.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/evm/interfaces/IMemory.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/evm/interfaces/IOpcode.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/evm/interfaces/IStorage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADD = void 0;
+const _is_1 = require("@dequanto/utils/$is");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+class ADD {
+    constructor(left, right) {
+        this.name = 'ADD';
+        this.wrapped = true;
+        this.left = left;
+        this.right = right;
+    }
+    toString() {
+        return (0, stringify_1.default)(this.left) + ' + ' + (0, stringify_1.default)(this.right);
+    }
+    get type() {
+        if (this.left.type === this.right.type) {
+            return this.left.type;
+        }
+        else if (!this.left.type && this.right.type) {
+            return this.right.type;
+        }
+        else if (!this.right.type && this.left.type) {
+            return this.left.type;
+        }
+        else {
+            return false;
+        }
+    }
+}
+exports.ADD = ADD;
+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) {
+        state.stack.push(right);
+    }
+    else if (_is_1.$is.BigInt(right) && right === 0n) {
+        state.stack.push(left);
+    }
+    else {
+        state.stack.push(new ADD(left, right));
+    }
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _is_1 = require("@dequanto/utils/$is");
+const add_1 = require("./add");
+const mod_1 = require("./mod");
+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 add_1.ADD(left, right), mod));
+    }
+};

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

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

package/dist/src/evm/opcodes/and.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.AND = void 0;
+const _is_1 = require("@dequanto/utils/$is");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+class AND {
+    constructor(left, right) {
+        this.name = 'AND';
+        this.wrapped = true;
+        this.left = left;
+        this.right = right;
+    }
+    toString() {
+        return (0, stringify_1.default)(this.left) + ' && ' + (0, stringify_1.default)(this.right);
+    }
+}
+exports.AND = AND;
+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) && /^[f]+$/.test(left.toString(16))) {
+        right.size = left.toString(16).length;
+        state.stack.push(right);
+    }
+    else if (_is_1.$is.BigInt(right) && /^[f]+$/.test(right.toString(16))) {
+        left.size = right.toString(16).length;
+        state.stack.push(left);
+        /*} else if (
+        $is.BigInt(left) &&
+        left.equals('1461501637330902918203684832716283019655932542975')
+    ) {*/
+        /* 2 ** 160 */
+        /*    state.stack.push(right);
+    } else if (
+        $is.BigInt(right) &&
+        right.equals('1461501637330902918203684832716283019655932542975')
+    ) {*/
+        /* 2 ** 160 */
+        /*    state.stack.push(left);*/
+    }
+    else if (_is_1.$is.BigInt(left) &&
+        right instanceof AND &&
+        _is_1.$is.BigInt(right.left) &&
+        left === right.left) {
+        state.stack.push(right.right);
+    }
+    else {
+        state.stack.push(new AND(left, right));
+    }
+};

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

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

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

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

package/dist/src/evm/opcodes/byte.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.BYTE = void 0;
+const _is_1 = require("@dequanto/utils/$is");
+const stringify_1 = __importDefault(require("../utils/stringify"));
+class BYTE {
+    constructor(position, data) {
+        this.name = 'BYTE';
+        this.wrapped = true;
+        this.position = position;
+        this.data = data;
+    }
+    toString() {
+        return '(' + (0, stringify_1.default)(this.data) + ' >> ' + (0, stringify_1.default)(this.position) + ') & 1';
+    }
+}
+exports.BYTE = BYTE;
+exports.default = (opcode, state) => {
+    const position = state.stack.pop();
+    const data = state.stack.pop();
+    if (_is_1.$is.BigInt(data) && _is_1.$is.BigInt(position)) {
+        state.stack.push((data >> position) & 1n);
+    }
+    else {
+        state.stack.push(new BYTE(position, data));
+    }
+};